diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index a9cdd0d88a066b473ec56f66313bb51bd2456464..96e0ce87853b9c65bc56756c71282a745453b22c 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,5 +1,8 @@
image: maven:latest
+cache:
+ key: EnigmaCache
+
stages:
- clean
- build
@@ -28,3 +31,6 @@ Deploy new version as Release:
script:
- mvn versions:set -DnewVersion=$CI_COMMIT_TAG
- mvn assembly:assembly
+ artifacts:
+ paths:
+ - target/*.jar
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
index 214f2036305afeed1fce2db5dedc4d2c3c89a847..eca5a29aee31cb8a47dfff0b974c65433079aa06 100644
--- a/LICENSE
+++ b/LICENSE
@@ -632,7 +632,7 @@ state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Enigma
- Copyright (C) 2019 AlfaTrainingKurse / Java
+ Copyright (C) 2019 Enigma@Java Developer Team
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
- Enigma Copyright (C) 2019 AlfaTrainingKurse / Java
+ Enigma Copyright (C) 2019 Enigma@Java Developer Team
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
diff --git a/README.md b/README.md
index 163ab611cc322893c21892be580514f5eeba300a..cbe467a3db48b637919ac74ff829920264d130ee 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,19 @@
[](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master)
-[](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master)
-Link zum [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home)
\ No newline at end of file
+### Eine Enigma Simulation in Java
+
+Dieses Projekt ist unsere Abschlußprüfung zur Java Fortbildung und deshalb in der Entwicklung nicht so weit fortgeschritten.\
+Wir haben jedoch trotzdem versucht, die Enigma möglichst original getreu nach zu bauen und versucht an die Regeln,\
+aus der damaligen Zeit zu halten.
+
+Falls ihr Spaß habt daran etwas weiter zu entwickeln, sind Merge-Requests herzlich willkommen.\
+\
+Ebenfalls eingebaut haben wir einen Funkraum. Heißt das man Nachrichten, per Morsecode, an einen externen Server senden kann\
+und auch wieder abholen kann.\
+Bitte beachtet das diese Nachrichten jeder lesen kann, wenn ihr die Standard Einstellungen aus dem Codebuch und die selbe Kenngruppe nutzt.\
+Das Codebuch ist fest, in einer sqlite Datei, im Resources Ordner, hinterlegt.\
+\
+Ebenfalls wichtig ist eure Kenngruppe. Dies hat früher den Personenkreis bezeichnet, welcher diese Nachrichten lesen durfte.\
+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.
diff --git a/pom.xml b/pom.xml
index ccec90007b7180a0e5217dd1c67323f132d5f920..680b9ad5b923a384115bb376c477879ec0abd7d2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,15 +1,15 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
- <groupId>Projektarbeit</groupId>
- <artifactId>Enigma</artifactId>
+ <groupId>projekt</groupId>
+ <artifactId>enigma</artifactId>
<version>0.0.1</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!--region[useage]-->
<use.java.version>11</use.java.version>
<use.javafx.version>11.0.2</use.javafx.version>
- <use.app.main.class>Enigma.Main</use.app.main.class>
+ <use.app.main.class>${project.groupId}.${project.artifactId}.Main</use.app.main.class>
<!--endregion[useage]-->
<maven.compiler.source>${use.java.version}</maven.compiler.source>
<maven.compiler.target>${use.java.version}</maven.compiler.target>
@@ -25,6 +25,12 @@
<artifactId>javafx-fxml</artifactId>
<version>${use.javafx.version}</version>
</dependency>
+ <!-- https://mvnrepository.com/artifact/net.sourceforge.plantuml/plantuml -->
+ <dependency>
+ <groupId>net.sourceforge.plantuml</groupId>
+ <artifactId>plantuml</artifactId>
+ <version>8059</version>
+ </dependency>
<!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
<dependency>
<groupId>org.xerial</groupId>
diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java
deleted file mode 100644
index 1e8c80902cf8d08f3c1da4ff39b18a55028dac21..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/App.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package Enigma;
-
-import javafx.application.Application;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.Parent;
-import javafx.scene.Scene;
-import javafx.stage.Stage;
-
-import java.io.IOException;
-
-/**
- * JavaFX App
- */
-public class App extends Application {
-
- private static Scene scene;
-
- @Override
- public void start(Stage stage) throws IOException {
- scene = new Scene(loadFXML("gui"));
- stage.setScene(scene);
- stage.show();
-
- }
-
- static void setRoot(String fxml) throws IOException {
- scene.setRoot(loadFXML(fxml));
- }
-
- private static Parent loadFXML(String fxml) throws IOException {
- FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
- return fxmlLoader.load();
- }
-
- public static void main(String[] args) {
- Application.launch();
- }
-
-}
\ No newline at end of file
diff --git a/src/main/java/Enigma/GuiController.java b/src/main/java/Enigma/GuiController.java
deleted file mode 100644
index 7e444ce2d9d8ea92ab29b90f1a76c37f048901a6..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/GuiController.java
+++ /dev/null
@@ -1,225 +0,0 @@
-package Enigma;
-
-import javafx.fxml.FXML;
-import javafx.scene.control.Label;
-import javafx.scene.control.MenuButton;
-import javafx.scene.control.MenuItem;
-
-import java.awt.event.ActionEvent;
-import java.util.ArrayList;
-import java.util.List;
-
-public class GuiController {
-
- @FXML
- private MenuButton w1;
-//
-// @FXML
-// private MenuItem w1I;
-//
-// @FXML
-// private MenuItem w1II;
-//
-// @FXML
-// private MenuItem w1III;
-// @FXML
-// private MenuItem w1IV;
-//
-// @FXML
-// private MenuItem w1V;
-
- @FXML
- private MenuButton w2;
- @FXML
- private MenuItem w2I;
-
- @FXML
- private MenuItem w2II;
-
- @FXML
- private MenuItem w2III;
-
- @FXML
- private MenuItem w2IV;
-
- @FXML
- private MenuItem w2V;
-
- @FXML
- private MenuButton w3;
-
- @FXML
- private MenuItem w3I;
-
- @FXML
- private MenuItem w3II;
-
- @FXML
- private MenuItem w3III;
- @FXML
- private MenuItem w3IV;
-
- @FXML
- private MenuItem w3V;
-
-
- @FXML
- void w3I(ActionEvent event) {
- }
-
- @FXML
- void w3II(ActionEvent event) {
- }
-
- @FXML
- void w3III(ActionEvent event) {
- }
- @FXML
- void w3IV(ActionEvent event) {
- }
- @FXML
- void w3V(ActionEvent event) {
- }
-
- @FXML
- void btnsenden(ActionEvent event) {
- }
- public void btnsenden(){
-
- }
-// @FXML
-// void w1I(ActionEvent event) {
-// }
-// @FXML
-// void w1II(ActionEvent event) {
-// }
-// @FXML
-// void w1III(ActionEvent event) {
-// }
-// @FXML
-// void w1IV(ActionEvent event) {
-// }
-// @FXML
-// void w1V(ActionEvent event) {
-// }
-
- @FXML
- void w2I(ActionEvent event) {
- }
- @FXML
- void w2II(ActionEvent event) {
- }
- @FXML
- void w2III(ActionEvent event) {
- }
- @FXML
- void w2IV(ActionEvent event) {
- }
- @FXML
- void w2V(ActionEvent event) {
- }
-
-// // Action Listener für erste Walze
-// public void w1I(){
-// w1.setText(w1I.getText());
-// }
-// public void w1II(){
-// w1.setText(w1II.getText());
-// }
-// public void w1III(){
-// w1.setText(w1III.getText());
-// }
-// public void w1IV(){
-// w1.setText(w1IV.getText());
-// }
-// public void w1V(){
-// w1.setText(w1V.getText());
-// }
- // Action Listener für zweite Walze
- public void w2I(){
- w2.setText(w2I.getText());
- }
- public void w2II(){
- w2.setText(w2II.getText());
- }
- public void w2III(){
- w2.setText(w2III.getText());
- }
- public void w2IV(){
- w2.setText(w2IV.getText());
- }
- public void w2V(){
- w2.setText(w2V.getText());
- }
- // Action Listener für dritte Walze
- public void w3I(){
- w3.setText(w3I.getText());
- }
- public void w3II(){
- w3.setText(w3II.getText());
- }
- public void w3III(){
- w3.setText(w3III.getText());
- }
- public void w3IV(){
- w3.setText(w3IV.getText());
- }
- public void w3V(){
- w3.setText(w3V.getText());
- }
-
- public void listener(MenuButton mb, MenuItem mi){
- mb.setText(mi.getText());
- }
-//
-// public void walzenListener(){
-// MenuItem[] buttons = {w1I,w1II,w1II,w1IV,w1V};
-// for (int i =0; i<6; i++) {
-// listener(w1, buttons[i]);
-// }
-// }
-
-
-
- @FXML
- void initialize() {
-
-// for (int i =0; i<6; i++) {
-//
-// mi.add(new MenuItem("W"+i));
-// }
-
- ArrayList<MenuItem> mi;
-
- for (int i =0; i<6; i++) {
- String[] str={"I","II","III","IV","V"};
- MenuItem mb2 = new MenuItem("W"+i);
- w1.getItems().add(mb2);
- // listener(w1,mb2);
- }
- // listener(w1,);
-
-
- // walzenListener();
-
- assert w1 != null : "fx:id=\"w1\" was not injected: check your FXML file 'primary.fxml'.";
-// assert w1I != null : "fx:id=\"w1I\" was not injected: check your FXML file 'primary.fxml'.";
-// assert w1II != null : "fx:id=\"w1II\" was not injected: check your FXML file 'primary.fxml'.";
-// assert w1III != null : "fx:id=\"w1III\" was not injected: check your FXML file 'primary.fxml'.";
-// assert w1IV != null : "fx:id=\"w1IV\" was not injected: check your FXML file 'primary.fxml'.";
-// assert w1V != null : "fx:id=\"w1V\" was not injected: check your FXML file 'primary.fxml'.";
- assert w3 != null : "fx:id=\"w3\" was not injected: check your FXML file 'primary.fxml'.";
- assert w3I != null : "fx:id=\"w3I\" was not injected: check your FXML file 'primary.fxml'.";
- assert w3II != null : "fx:id=\"w3II\" was not injected: check your FXML file 'primary.fxml'.";
- assert w3III != null : "fx:id=\"w3III\" was not injected: check your FXML file 'primary.fxml'.";
- assert w3IV != null : "fx:id=\"w3IV\" was not injected: check your FXML file 'primary.fxml'.";
- assert w3V != null : "fx:id=\"w3V\" was not injected: check your FXML file 'primary.fxml'.";
- assert w2 != null : "fx:id=\"w2\" was not injected: check your FXML file 'primary.fxml'.";
- assert w2I != null : "fx:id=\"w2I\" was not injected: check your FXML file 'primary.fxml'.";
- assert w2II != null : "fx:id=\"w2II\" was not injected: check your FXML file 'primary.fxml'.";
- assert w2III != null : "fx:id=\"w2III\" was not injected: check your FXML file 'primary.fxml'.";
- assert w2IV != null : "fx:id=\"w2IV\" was not injected: check your FXML file 'primary.fxml'.";
- assert w2V != null : "fx:id=\"w2V\" was not injected: check your FXML file 'primary.fxml'.";
- }
-
-}
diff --git a/src/main/java/Enigma/model/Codebuch.java b/src/main/java/Enigma/model/Codebuch.java
deleted file mode 100644
index 0c6d01da135415010d27909d1a07f604de085f00..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/model/Codebuch.java
+++ /dev/null
@@ -1,144 +0,0 @@
-package Enigma.model;
-
-/**
- * Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
- * Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
- * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
- * mussten um die Texte zu ver/entschlüsseln.
- * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
- * vorgenommen.
- * Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
- * festgelegt war.
- *
- * Dieses Codebuch Objekt enthält die Einstellungen eines Tages, welche mittels Getter und Setter
- * verarbeitet werden können.
- *
- * Zusätzlich gibt es zu Debug Zwecken eine überschriebene toString Funktion welche das Objekt als String zurück
- * geben kann.
- */
-public class Codebuch {
- private int tag;
- private String[] Walzenlage;
- private String[] Ringstellung;
- private String[] Steckverbindung;
-
- Codebuch() {
- this.Walzenlage = new String[3];
- this.Ringstellung = new String[3];
- this.Steckverbindung = new String[10];
- }
-
- /**
- * Gibt die aktuelle Instanz des Codebuches als String zurück.
- * Hierbei werden der Tag die Walzenlagen, Ring/Grundstellung sowie die Steckverbindungen zurück gegeben.
- *
- * @return String : String des gesamten Objektes
- */
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder();
- boolean wlLoop = false;
- boolean rsLoop = false;
- boolean svLoop = false;
-
- sb.append("Tag: ").append(this.getTag()).append("\n");
-
- sb.append("Walzenlage: ");
- for(String wl : this.getWalzenlage()) {
- sb.append(wl).append(",");
- wlLoop = true;
- }
- if(wlLoop) {
- sb.setLength(sb.length() - 1);
- }
- sb.append("\n");
-
- sb.append("Ringstellung: ");
- for(String rs : this.getRingstellung()) {
- sb.append(rs).append(",");
- rsLoop = true;
- }
- if(rsLoop) {
- sb.setLength(sb.length() - 1);
- }
- sb.append("\n");
-
- sb.append("Steckverbindung: ");
- for (String s : this.getSteckverbindung()) {
- if (!s.isEmpty()) {
- sb.append(s).append(",");
- svLoop = true;
- }
- }
- if(svLoop) {
- sb.setLength(sb.length() - 1);
- }
- sb.append("\n");
-
- return sb.toString();
- }
-
- /**
- * Gibt den Tag dieser Instanz zurück
- * @return int : Tag
- */
- public int getTag() {
- return tag;
- }
-
- /**
- * Gibt die Walzenlage dieser Instanz zurück
- * @return String[] : Walzenlage
- */
- public String[] getWalzenlage() {
- return Walzenlage;
- }
-
- /**
- * Gibt die Ringstellung dieser Instanz zurück
- * @return String[] : Ringstellung
- */
- public String[] getRingstellung() {
- return Ringstellung;
- }
-
- /**
- * Gibt die Steckverbindung dieser Instanz zurück
- * @return String[] : Steckverbindung
- */
- public String[] getSteckverbindung() {
- return Steckverbindung;
- }
-
- /**
- * Setzt den Tag dieser Instanz
- * @param tag : int
- */
- public void setTag(int tag) {
- this.tag = tag;
- }
-
- /**
- * Setzt die Walzenlage dieser Instanz
- * @param walzenlage : String[]
- */
- public void setWalzenlage(String[] walzenlage) {
- Walzenlage = walzenlage;
- }
-
- /**
- * Setzt die Ringstellung dieser Instanz
- * @param ringstellung : String[]
- */
- public void setRingstellung(String[] ringstellung) {
- Ringstellung = ringstellung;
- }
-
- /**
- * Setzt die Steckverbindung dieser Instanz
- * @param steckverbindung : String[]
- */
- public void setSteckverbindung(String[] steckverbindung) {
- Steckverbindung = steckverbindung;
- }
-}
diff --git a/src/main/java/Enigma/model/Reflektor.java b/src/main/java/Enigma/model/Reflektor.java
deleted file mode 100644
index cc7c69dc5d6291056189ae515715aa2ddb1356a1..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/model/Reflektor.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package Enigma.model;
-
-/**
- * Klasse Reflektor
- *
- * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
- * Der kodierte Buchstabe wird an die Klasse Walze wieder zurückgegeben.
- *
- * Prinzipiell verhält sich die Klasse Refelktor wie die Klasse Walze, außer das sie sich
- * nach Betätigung einer Taste nicht dreht (starr montiert) und sie gibt keine Signale
- * an andere Walzen zum drehen.
- */
-public class Reflektor {
-
- /**
- * Konstanten und Variablen der Klasse Reflektor
- *
- * WALZE_ALPHABET : konstanter Char-Array mit den Werten des Alphabeths (26 Werte)
- * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte)
- * reflektorBuchstabeRein : Character mit dem an die Klasse übergebenen Character
- * reflektorBuchstabeRaus : Character nach der Codierung in der Klasse Reflektor
- * iPositionReflektor : Integer mit der Positionsnummer des Characters im Array
- */
- private final Character[] WALZE_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'};
- private final Character[] WALZE_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'};
- private Character reflektorBuchstabeRein;
- private Character reflektorBuchstabeRaus;
- private int iPositionReflektor;
-
-
- /**
- * Funktion Codiere
- *
- * Durchsucht das konstante Char-Array WALZE_ALPHABET nach der Position eines bestimmten
- * Buchstabens und gibt den Character an der entsprechenden Position im konstanten
- * Char-Array WALZE_REFLEKTOR zurück.
- *
- * @return reflektorBuchstabeRaus: Character: Der kodierte Buchstabe aus dem Reflektor
- */
- public char codiere (){
- int index = 0;
-
- /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
- for(index = 0; index < WALZE_ALPHABET.length; index++) {
- if(getReflektorBuchstabeRein().equals(WALZE_ALPHABET[index])) {
- iPositionReflektor = index;
- break;
- }
- }
- /*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
- reflektorBuchstabeRaus = WALZE_REFLEKTOR[iPositionReflektor];
- return reflektorBuchstabeRaus;
- }
-
- /**
- * Getter getReflektorBuchstabeRein
- *
- * Gibt den Wert der Variablen reflektorBuchstabeRein zurück
- *
- * @return reflektorBuchstabeRein: Character: gibt den Buchstaben zurück
- */
- public Character getReflektorBuchstabeRein() {
- return reflektorBuchstabeRein;
- }
-
-
- /**
- * Setter setReflektorBuchstabeRein
- *
- * Setzt den Wert der Variablen reflektorBuchstabeRein
- *
- * @param reflektorBuchstabeRein: Character: setzt den Wert des Buchstabens
- */
- public void setReflektorBuchstabeRein(Character reflektorBuchstabeRein) {
- if (Character.isLetter(reflektorBuchstabeRein)){
- this.reflektorBuchstabeRein = reflektorBuchstabeRein;
- } else{
- System.err.println("Kein Buchstabe übergeben im Reflektor");
- }
-
- }
-
-}
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
deleted file mode 100644
index 9ad536e3a3a67ec8f1f75500d4c66799aa893614..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/model/Walze.java
+++ /dev/null
@@ -1,219 +0,0 @@
-package Enigma.model;
-
-public class Walze {
-
- private Character buchstabe;
- private Character ringstellung;
- private int walzennr;
- private int iPositionBuchstabe;
- private int iPositionBuchstabeRe;
- private Character[] walze;
-
- /**
- * Gibt die Parameter der Walze mit
- *
- * @param walzennr : int : Nummer der gewaehlten Walze
- * @param buchstabe : Character : Grundeinstellung der Walze
- * @param ringstellung : Character : Einstellung des Notch
- */
- public Walze(int walzennr, Character buchstabe, Character ringstellung) {
- this.walze = new Character[25];
- this.walzennr = walzennr;
- this.buchstabe = buchstabe;
- this.ringstellung = ringstellung;
- }
-
- /**
- * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
- */
- public Character getBuchstabe() {
- return buchstabe;
- }
-
- /**
- * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
- * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
- * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
- *
- * @param buchstabe : Character : Grundeinstellung der Walze
- */
- public void setBuchstabe(Character buchstabe) {
-
- if(Character.isLetter(buchstabe)) {
- this.buchstabe = Character.toUpperCase(buchstabe);
- } else {
- this.buchstabe = 'A';
- }
- }
-
- /**
- * @return ringstellung : Character : gibt die neue Ringstellung zurueck
- */
- public Character getRingstellung() {
- return ringstellung;
- }
-
-
- /**
- * Gibt die Initiale Ringstellung der Walze an.
- * Es sind nur Zahlen von 1 - 26 zugelassen.
- * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
- *
- * @param ringstellung : Character : Punkt an dem die Walze umspringt
- */
- public void setRingstellung(Character ringstellung) {
-
- if(Character.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
- this.ringstellung = ringstellung;
- } else {
- this.ringstellung = '1';
- }
- }
-
- /**
- * @return walzennr : int : gibt die Walzennummer zurueck
- */
- public int getWalzennr() {
- return walzennr;
- }
-
- /**
- * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
- *
- * @param walzennr : int : setzt die Walzennummer
- */
- public void setWalzennr(int walzennr) {
- if(walzennr > 0 && walzennr < 6) {
- this.walzennr = walzennr;
- } else {
- System.err.println("Keine gültige Walzennummer");
- }
- }
-
- /**
- * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
- *
- * @return walze : Character[] : gibt die gewaehlte Walze zurueck
- */
- private Character[] walzenNummer() {
-
- /*Walze nach der Chiffrierung*/
- Character[] walzeEins = {'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'};
- Character[] walzeZwei = {'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'};
- Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
- Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
- Character[] walzeFuenf = {'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'};
-
- switch (getWalzennr()) {
- case 1:
- walze = walzeEins;
- break;
- case 2:
- walze = walzeZwei;
- break;
- case 3:
- walze = walzeDrei;
- break;
- case 4:
- walze = walzeVier;
- break;
- case 5:
- walze = walzeFuenf;
- break;
- }
-
- return walze;
- }
-
- /**
- * Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
- * der Chiffrierung auf der gewaehlten Walze abgleichen zu koennen.
- *
- * @return iPositionBuchstabe : int : Position des Buchstaben im Array
- */
- public int positionBuchstabe() {
-
- /*Alphabetswalze*/
- Character[] walzeAlpha = {'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'};
-
- /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
- for(int index = 0; index < walzeAlpha.length; index++) {
- if(getBuchstabe().equals(walzeAlpha[index])) {
- iPositionBuchstabe = index;
- break;
- }
- }
-
- return iPositionBuchstabe;
- }
-
-
- /**
- * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
- * anhand der gewaehlten Walze.
- *
- * @param iPositionBuchstabe : int : Position des zu chiffrierenden Buchstabens
- * @param walze : Character[] : ausgewaehlte Walze
- * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
- */
- public Character codiereBuchstabe(int iPositionBuchstabe, Character[] walze) {
- Character codierterBuchstabe = walze[iPositionBuchstabe];
- return codierterBuchstabe;
- }
-
-
- /**
- * Nimmt die Startposition, die aus der Walzeneinstellung geholt wird und
- * erhoeht sie um eins.
- * Die Variable wird ueberschrieben und zaehlt von nun an die Position mit.
- * Ab Position 25 wird wieder bei 0 angefangen.
- *
- * @param iPositionBuchstabe : int : alte Position der Walze
- * @return iPositionBuchstabe : int : neue Position der Walze
- */
- public int vorstellenDerWalze(int iPositionBuchstabe) {
-
- if(iPositionBuchstabe == 25) {
- iPositionBuchstabe = 0;
- } else {
- iPositionBuchstabe += 1;
- }
-
- return iPositionBuchstabe;
- }
-
- /**
- * Ermittelt die Position des Buchstaben auf der gewaehlten Walze, um die Position mit
- * der Chiffrierung auf der AlphaWalze abgleichen zu koennen.
- *
- * @param walzennr : int : gibt die gewaehlte Walze zurueck
- * @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
- */
- public int positionBuchstabeReverse(int walzennr) {
-
- /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
- for(int index = 0; index < walze.length; index++) {
- if(getBuchstabe().equals(walze[index])) {
- iPositionBuchstabeRe = index;
- break;
- }
- }
- return iPositionBuchstabeRe;
- }
-
- /**
- * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
- * anhand der AlphaWalze.
- *
- * @param iPositionBuchstabeRe : int : Position des zu chiffrierenden Buchstabens
- * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
- */
- public Character codierterBuchstabeReverse(int iPositionBuchstabeRe) {
- /*Alphawalze*/
- Character[] walzeAlpha = {'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'};
-
- Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
- return codierterBuchstabeRe;
- }
-
-}
diff --git a/src/main/java/projekt/enigma/App.java b/src/main/java/projekt/enigma/App.java
new file mode 100644
index 0000000000000000000000000000000000000000..72a9b8a5bb3b6636a3e15044ac516f19eae64eb5
--- /dev/null
+++ b/src/main/java/projekt/enigma/App.java
@@ -0,0 +1,67 @@
+package projekt.enigma;
+
+import projekt.enigma.model.Codierer;
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import java.io.IOException;
+
+/**
+ * JavaFX App
+ */
+public class App extends Application {
+
+ /**
+ * TODO Dokumentieren
+ */
+ private static Scene scene;
+ private Codierer c;
+
+ /**
+ * TODO Dokumentieren
+ *
+ * @param fxml
+ * @throws IOException
+ */
+ static void setRoot(String fxml) throws IOException {
+ scene.setRoot(loadFXML(fxml));
+ }
+
+ /**
+ * TODO Dokumentieren
+ *
+ * @param fxml
+ * @return
+ * @throws IOException
+ */
+ private static Parent loadFXML(String fxml) throws IOException {
+ FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
+ return fxmlLoader.load();
+ }
+
+ /**
+ * TODO Dokumentieren
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ Application.launch();
+ }
+
+ /**
+ * TODO Dokumentieren
+ *
+ * @param stage
+ * @throws IOException
+ */
+ @Override
+ public void start(Stage stage) throws IOException {
+ scene = new Scene(loadFXML("gui"));
+ stage.setScene(scene);
+ stage.setResizable(true);
+ stage.show();
+ }
+
+}
diff --git a/src/main/java/projekt/enigma/GuiController.java b/src/main/java/projekt/enigma/GuiController.java
new file mode 100644
index 0000000000000000000000000000000000000000..d88fdd57956dae55db68d58c67429ce1bd56fd9a
--- /dev/null
+++ b/src/main/java/projekt/enigma/GuiController.java
@@ -0,0 +1,451 @@
+package projekt.enigma;
+
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.control.*;
+import javafx.scene.shape.Circle;
+import org.apache.http.HttpException;
+import projekt.enigma.model.Codierer;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class GuiController {
+
+ //region Klassenvariablen
+ private final static String[] walzenNr = {"I", "II", "III", "IV", "V"};
+ private final static String[] ringNr = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26"};
+ private final static String[] position = {"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"};
+ private ArrayList<MenuItem> mItem;
+ private String textEingabe;
+ private String textCodiert;
+ private boolean resetDisplay;
+ private Codierer codierer;
+//endregion
+
+ //region GUI-Elemente
+ @FXML
+ private TextField tfStecker1, tfStecker2, tfStecker3, tfStecker4, tfStecker5, tfStecker6, tfStecker7, tfStecker8,
+ tfStecker9, tfStecker10, tfCodiert, tfKlartext;
+
+ @FXML
+ private Button btnA, btnB, btnC, btnD, btnE, btnF, btnG, btnH, btnI, btnJ, btnK, btnL, btnM, btnN, btnO, btnP, btnQ,
+ btnR, btnS, btnT, btnU, btnV, btnW, btnX, btnY, btnZ, btnSenden, btnEmpfangen, btnDelete;
+
+ @FXML
+ private Circle circA, circB, circC, circD, circE, circF, circG, circH, circI, circJ, circK, circL, circM, circN,
+ circO, circP, circQ, circR, circS, circT, circU, circV, circW, circX, circY, circZ;
+
+ @FXML
+ private Label lblA, lblB, lblC, lblD, lblE, lblF, lblG, lblH, lblI, lblJ, lblK, lblL, lblM, lblN, lblO, lblP, lblQ,
+ lblR, lblS, lblT, lblU, lblV, lblW, lblX, lblY, lblZ, lblLadeNachricht, lblTagesschluessel,
+ lblSpruchschluessel;
+
+ @FXML
+ private ProgressBar pbLadeNachricht;
+
+ @FXML
+ private MenuButton mBtnWalzPos1, mBtnWalzPos2, mBtnWalzPos3, mBtnNotchPos1, mBtnNotchPos2, mBtnNotchPos3,
+ mBtnStartPos1, mBtnStartPos2, mBtnStartPos3;
+//endregion
+
+ //region Init
+ @FXML
+ void initialize() {
+
+ // Variablen setzen
+ textEingabe = "";
+ textCodiert = "";
+ resetDisplay = true;
+
+ //Einträge für Walzen
+ menu(mBtnWalzPos1, walzenNr);
+ menu(mBtnWalzPos2, walzenNr);
+ menu(mBtnWalzPos3, walzenNr);
+
+ //Einträge für die Ringe
+ menu(mBtnNotchPos1, ringNr);
+ menu(mBtnNotchPos2, ringNr);
+ menu(mBtnNotchPos3, ringNr);
+
+ //Einträge für die Startpositionen
+ menu(mBtnStartPos1, position);
+ menu(mBtnStartPos3, position);
+ menu(mBtnStartPos2, position);
+
+ //Setze Leucht Event bei Tastendruck
+ leuchten(btnA, circA);
+ leuchten(btnB, circB);
+ leuchten(btnC, circC);
+ leuchten(btnD, circD);
+ leuchten(btnE, circE);
+ leuchten(btnF, circF);
+ leuchten(btnG, circG);
+ leuchten(btnH, circH);
+ leuchten(btnI, circI);
+ leuchten(btnJ, circJ);
+ leuchten(btnK, circK);
+ leuchten(btnL, circL);
+ leuchten(btnM, circM);
+ leuchten(btnN, circN);
+ leuchten(btnO, circO);
+ leuchten(btnP, circP);
+ leuchten(btnQ, circQ);
+ leuchten(btnR, circR);
+ leuchten(btnS, circS);
+ leuchten(btnT, circT);
+ leuchten(btnU, circU);
+ leuchten(btnV, circV);
+ leuchten(btnW, circW);
+ leuchten(btnX, circX);
+ leuchten(btnY, circY);
+ leuchten(btnZ, circZ);
+
+ // Initialisieren des Codierers und setzen der Kenngruppe
+ this.codierer = new Codierer();
+ this.codierer.setKenngruppe("enigma");
+
+ // Beim nächsten Tastendruck erstmal das Display löschen damit falschen Nachrichten geschickt werden.
+ this.resetDisplay = true;
+
+ // Einstellungen aus dem Logbuch auslesen und setzen
+ this.setzeTagesSchluessel();
+ this.setzeSteckverbindungen();
+ }
+
+ /**
+ * init Methode zur Erstellung der Einträge und Action Listener für die einzelnen Menüs
+ *
+ * @param button : Button für die die Einträge erstellt werden sollen
+ */
+ private void menu(MenuButton button, String[] str) {
+ mItem = new ArrayList<>();
+ for (int i = 0; i < str.length; i++) {
+ //Eintrag aus str der Arraylist mi hinzufügen
+ mItem.add(new MenuItem(str[i]));
+ //MenuItem mi dem Button button hinzufügen
+ button.getItems().add(mItem.get(i));
+ int finalI = i;
+ //Listener für die einzelnen Einträge
+ ArrayList<MenuItem> finalMi = mItem;
+ mItem.get(i).setOnAction(e -> setMenuBtnText(button, finalMi.get(finalI)));
+ }
+ }
+//endregion
+
+ //region EventHandler/Listener
+
+ /**
+ * //TODO DOKU
+ */
+ private void leuchten(Button taste, Circle leuchte) {
+
+ taste.setOnMousePressed(mouseEvent -> leuchte.setStyle("-fx-fill: #FFA500"));
+ taste.setOnMouseReleased(mouseEvent -> {
+ leuchte.setStyle("-fx-background-color: " + taste.getBackground());
+ leuchte.setStyle("-fx-border-color: #000000");
+ });
+ }
+
+ /**
+ * Auswertung welcher Button gedrückt wurde
+ *
+ * @param e => ActionEvent des auslösenden Button
+ */
+ @FXML
+ private void gedrueckteTaste(ActionEvent e) {
+
+ //TODO Anbindung an Klasse Hardware
+ if (e.getSource() == btnA) {
+ setText(btnA);
+ //leuchten();
+ }
+ if (e.getSource() == btnB) setText(btnB);
+ if (e.getSource() == btnC) setText(btnC);
+ if (e.getSource() == btnD) setText(btnD);
+ if (e.getSource() == btnE) setText(btnE);
+ if (e.getSource() == btnF) setText(btnF);
+ if (e.getSource() == btnG) setText(btnG);
+ if (e.getSource() == btnH) setText(btnH);
+ if (e.getSource() == btnI) setText(btnI);
+ if (e.getSource() == btnJ) setText(btnJ);
+ if (e.getSource() == btnK) setText(btnK);
+ if (e.getSource() == btnL) setText(btnL);
+ if (e.getSource() == btnM) setText(btnM);
+ if (e.getSource() == btnN) setText(btnN);
+ if (e.getSource() == btnO) setText(btnO);
+ if (e.getSource() == btnP) setText(btnP);
+ if (e.getSource() == btnQ) setText(btnQ);
+ if (e.getSource() == btnR) setText(btnR);
+ if (e.getSource() == btnS) setText(btnS);
+ if (e.getSource() == btnT) setText(btnT);
+ if (e.getSource() == btnU) setText(btnU);
+ if (e.getSource() == btnV) setText(btnV);
+ if (e.getSource() == btnW) setText(btnW);
+ if (e.getSource() == btnX) setText(btnX);
+ if (e.getSource() == btnY) setText(btnY);
+ if (e.getSource() == btnZ) setText(btnZ);
+ if (e.getSource() == btnSenden) sendeFunkspruch();
+ if (e.getSource() == btnEmpfangen) empfangeFunkspruch();
+ if (e.getSource() == btnDelete) loeschen();
+ }
+//endregion
+
+ //region Methoden
+
+ /**
+ * Methode zum setzen des menuButton Textes auf das ausgewählte MenuItem
+ *
+ * @param mBtn : MenuButton der Walze
+ * @param mItm : MenuItem
+ */
+ private void setMenuBtnText(MenuButton mBtn, MenuItem mItm) {
+ // mb.setText(mi.getText());
+
+ if (mBtn.getId().equals(mBtnStartPos1.getId())) setzePosition(1, mItm.getText().charAt(0));
+ if (mBtn.getId().equals(mBtnStartPos2.getId())) setzePosition(2, mItm.getText().charAt(0));
+ if (mBtn.getId().equals(mBtnStartPos3.getId())) setzePosition(3, mItm.getText().charAt(0));
+ if (mBtn.getId().equals(mBtnWalzPos1.getId())) setzeWalze(1, mItm.getText());
+ if (mBtn.getId().equals(mBtnWalzPos2.getId())) setzeWalze(2, mItm.getText());
+ if (mBtn.getId().equals(mBtnWalzPos3.getId())) setzeWalze(3, mItm.getText());
+ if (mBtn.getId().equals(mBtnNotchPos1.getId()))
+ setzeRing(1, Integer.parseInt(mItm.getText()) - 1);
+ if (mBtn.getId().equals(mBtnNotchPos2.getId()))
+ setzeRing(2, Integer.parseInt(mItm.getText()) - 1);
+ if (mBtn.getId().equals(mBtnNotchPos3.getId()))
+ setzeRing(3, Integer.parseInt(mItm.getText()) - 1);
+ }
+
+ /**
+ * Hier werden die TextFelder, welche die Steckverbindungen darstellen,
+ * mit dem Werten die die Klasse Codierer zur Verfügung stellt gefüllt.
+ */
+ private void setzeSteckverbindungen() {
+ tfStecker1.setText(codierer.getSteckverbindungen()[0][0] + "" + codierer.getSteckverbindungen()[0][1]);
+ tfStecker2.setText(codierer.getSteckverbindungen()[1][0] + "" + codierer.getSteckverbindungen()[1][1]);
+ tfStecker3.setText(codierer.getSteckverbindungen()[2][0] + "" + codierer.getSteckverbindungen()[2][1]);
+ tfStecker4.setText(codierer.getSteckverbindungen()[3][0] + "" + codierer.getSteckverbindungen()[3][1]);
+ tfStecker5.setText(codierer.getSteckverbindungen()[4][0] + "" + codierer.getSteckverbindungen()[4][1]);
+ tfStecker6.setText(codierer.getSteckverbindungen()[5][0] + "" + codierer.getSteckverbindungen()[5][1]);
+ tfStecker7.setText(codierer.getSteckverbindungen()[6][0] + "" + codierer.getSteckverbindungen()[6][1]);
+ tfStecker8.setText(codierer.getSteckverbindungen()[7][0] + "" + codierer.getSteckverbindungen()[7][1]);
+ tfStecker9.setText(codierer.getSteckverbindungen()[8][0] + "" + codierer.getSteckverbindungen()[8][1]);
+ tfStecker10.setText(codierer.getSteckverbindungen()[9][0] + "" + codierer.getSteckverbindungen()[9][1]);
+ }
+
+ /**
+ * Die Löschen Funktion löscht das letzte Zeichen im Klartext sowie im Codiert Feld,
+ * der Codierer wird aufgerufen um ebenfalls das letzte Zeichen zu löschen
+ */
+ private void loeschen() {
+ if (textEingabe.length() == 0) {
+ tfKlartext.setText("");
+ tfCodiert.setText("");
+ } else {
+ textEingabe = textEingabe.substring(0, textEingabe.length() - 1);
+ textCodiert = textCodiert.substring(0, textCodiert.length() - 1);
+ tfKlartext.setText(textEingabe);
+ tfCodiert.setText(textCodiert);
+ codierer.letztesZeichenLoeschen();
+ mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
+ mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
+ mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+ }
+ }
+
+ /**
+ * //TODO DOKU
+ */
+ void empfangeFunkspruch() {
+ String[] empfangeneNachricht = this.codierer.empfangeNachricht();
+ if (empfangeneNachricht[0] != null) {
+ this.tfKlartext.setText(empfangeneNachricht[2]);
+ this.tfCodiert.setText(empfangeneNachricht[1]);
+ this.resetDisplay = true;
+
+ // Spruchschluessel in das Feld lblSpruchschluessel schreiben
+ lblSpruchschluessel.setText(this.codierer.empfangenerSpruchschluessel(empfangeneNachricht[2]));
+
+ this.setzeTagesSchluessel();
+ }
+ }
+
+ /**
+ * //TODO DOKU
+ */
+ private void sendeFunkspruch() {
+ this.tfKlartext.setText("");
+ this.tfCodiert.setText("");
+
+ try {
+ this.codierer.sendeNachricht();
+ } catch (HttpException | IOException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ /**
+ * schreibt Buchstaben des gedrückten Knopfes in Textfeld tfrein
+ *
+ * @param pressedButton : gedrückter Knopf
+ */
+ private void setText(Button pressedButton) {
+ if (textEingabe.length() < 250) {
+ if (this.resetDisplay) {
+ this.tfCodiert.setText("");
+ this.tfKlartext.setText("");
+ this.resetDisplay = false;
+ this.codierer.resetHardware();
+ textCodiert = "";
+ textEingabe = "";
+ // Spruchschlüssel generieren und codieren
+ this.codierer.generateSpruchschluessel();
+ // Spruchschluessel in das Feld lblSpruchschluessel schreiben
+ lblSpruchschluessel.setText(this.codierer.getSpruchschluessel());
+ }
+ textEingabe += pressedButton.getText();
+ textCodiert += this.codierer.codiere(pressedButton.getText().charAt(0), true);
+
+ tfKlartext.setText(textEingabe);
+ tfCodiert.setText(textCodiert);
+
+ // Position der Walzen aktuallisieren
+ mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
+ mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
+ mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+ }
+ }
+
+ /**
+ * Setzt die Anzeige des entsprechende Gui-Element auf die entsprechende Walze
+ * ->d.h. welche Walze sitzt auf welcher Position
+ *
+ * @param walzeRoemischNr => gibt die Walzennummer an
+ * @param walzenPosition => gibt die Position der Walze
+ */
+ private void setzeWalze(int walzenPosition, String walzeRoemischNr) {
+ int walzeNr = 0;
+ switch (walzeRoemischNr) {
+ case "I":
+ walzeNr = 0;
+ break;
+ case "II":
+ walzeNr = 1;
+ break;
+ case "III":
+ walzeNr = 2;
+ break;
+ case "IV":
+ walzeNr = 4;
+ break;
+ case "V":
+ walzeNr = 4;
+ break;
+ default:
+ break;
+ }
+
+ switch (walzenPosition) {
+ case 1:
+ mBtnWalzPos1.setText(walzenNr[walzeNr]);
+ //codierer.setWalze(walzeNr, walzenPosition)
+ break;
+ case 2:
+ mBtnWalzPos2.setText(walzenNr[walzeNr]);
+ break;
+ case 3:
+ mBtnWalzPos3.setText(walzenNr[walzeNr]);
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ * Setzt den Notch (position)=> die Mitnahmeposition der Walze (walze) fest
+ * Mitnahmeposition meint => die nächste Walze wird bei erreichen dieser Position (notch)
+ * um eine Stelle versetzt
+ *
+ * @param ringStellung => gibt die walze an
+ * @param walzenPosition => gibt den notch der Walze (walze) an
+ */
+ private void setzeRing(int walzenPosition, int ringStellung) {
+ switch (walzenPosition) {
+ case 1:
+ mBtnNotchPos1.setText(ringNr[ringStellung]);
+ break;
+ case 2:
+ mBtnNotchPos2.setText(ringNr[ringStellung]);
+ break;
+ case 3:
+ mBtnNotchPos3.setText(ringNr[ringStellung]);
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ * Setzt die Startposition/ aktuelle Position der Walze
+ *
+ * @param walze => gibt die walze an
+ * @param buchstabe gibt den Startwert bzw die aktuelle Position der Walze (walze) an
+ */
+ private void setzePosition(int walze, char buchstabe) {
+ switch (walze) {
+ case 1:
+ mBtnStartPos1.setText(String.valueOf(buchstabe));
+ break;
+ case 2:
+ mBtnStartPos2.setText(buchstabe + "");
+ break;
+ case 3:
+ mBtnStartPos3.setText(buchstabe + "");
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ * Setzt den aktuellen TagesSchluessel
+ */
+ public void setzeTagesSchluessel() {
+
+ // Umsprungpunkte anzeigen
+ mBtnNotchPos1.setText(String.valueOf(this.codierer.fetchRingstellung()[0]));
+ mBtnNotchPos2.setText(String.valueOf(this.codierer.fetchRingstellung()[1]));
+ mBtnNotchPos3.setText(String.valueOf(this.codierer.fetchRingstellung()[2]));
+ // Walzennummern anzeigen
+ mBtnWalzPos1.setText(String.valueOf(this.codierer.getchWalzenNr()[0]));
+ mBtnWalzPos2.setText(String.valueOf(this.codierer.getchWalzenNr()[1]));
+ mBtnWalzPos3.setText(String.valueOf(this.codierer.getchWalzenNr()[2]));
+ // Position der Walzen anzeigen
+ mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
+ mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
+ mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+ // Steckbrett Felder setzen
+ tfStecker1.setText(this.codierer.getSteckverbindungen()[0][0] + "" +
+ this.codierer.getSteckverbindungen()[0][1]);
+ tfStecker2.setText(this.codierer.getSteckverbindungen()[1][0] + "" +
+ this.codierer.getSteckverbindungen()[1][1]);
+ tfStecker3.setText(this.codierer.getSteckverbindungen()[2][0] + "" +
+ this.codierer.getSteckverbindungen()[2][1]);
+ tfStecker4.setText(this.codierer.getSteckverbindungen()[3][0] + "" +
+ this.codierer.getSteckverbindungen()[3][1]);
+ tfStecker5.setText(this.codierer.getSteckverbindungen()[4][0] + "" +
+ this.codierer.getSteckverbindungen()[4][1]);
+ tfStecker6.setText(this.codierer.getSteckverbindungen()[5][0] + "" +
+ this.codierer.getSteckverbindungen()[5][1]);
+ tfStecker7.setText(this.codierer.getSteckverbindungen()[6][0] + "" +
+ this.codierer.getSteckverbindungen()[6][1]);
+ tfStecker8.setText(this.codierer.getSteckverbindungen()[7][0] + "" +
+ this.codierer.getSteckverbindungen()[7][1]);
+ tfStecker9.setText(this.codierer.getSteckverbindungen()[8][0] + "" +
+ this.codierer.getSteckverbindungen()[8][1]);
+ tfStecker10.setText(this.codierer.getSteckverbindungen()[9][0] + "" +
+ this.codierer.getSteckverbindungen()[9][1]);
+ }
+ //endregion
+}
diff --git a/src/main/java/Enigma/SecondaryController.java b/src/main/java/projekt/enigma/KenngruppeController.java
similarity index 59%
rename from src/main/java/Enigma/SecondaryController.java
rename to src/main/java/projekt/enigma/KenngruppeController.java
index 360bb06245d64f0367068d81be1f0ab2587ff7f6..3371b0f647ea6f27a72082ae0f18a44b79faf489 100644
--- a/src/main/java/Enigma/SecondaryController.java
+++ b/src/main/java/projekt/enigma/KenngruppeController.java
@@ -1,12 +1,12 @@
-package Enigma;
+package projekt.enigma;
import java.io.IOException;
import javafx.fxml.FXML;
-public class SecondaryController {
+public class KenngruppeController {
@FXML
private void switchToPrimary() throws IOException {
- App.setRoot("primary");
+ App.setRoot("gui");
}
}
\ No newline at end of file
diff --git a/src/main/java/Enigma/Main.java b/src/main/java/projekt/enigma/Main.java
similarity index 56%
rename from src/main/java/Enigma/Main.java
rename to src/main/java/projekt/enigma/Main.java
index 2bfc594ce53b57275c180938447de3ea3a866f17..f016016d5dd3ebc14cae30918487a14eec35ac8e 100644
--- a/src/main/java/Enigma/Main.java
+++ b/src/main/java/projekt/enigma/Main.java
@@ -1,8 +1,5 @@
-package Enigma;
+package projekt.enigma;
-import Enigma.model.Codebuch;
-import Enigma.model.DatenbankSqlite;
-import Enigma.model.Morsecode;
import java.sql.SQLException;
diff --git a/src/main/java/Enigma/model/DatenbankSqlite.java b/src/main/java/projekt/enigma/database/DatenbankSqlite.java
similarity index 60%
rename from src/main/java/Enigma/model/DatenbankSqlite.java
rename to src/main/java/projekt/enigma/database/DatenbankSqlite.java
index 891c011a036f01b038400dbb808d65c11a0b8f43..ac7c9024be694baff54f6573ac70dc695fc45081 100644
--- a/src/main/java/Enigma/model/DatenbankSqlite.java
+++ b/src/main/java/projekt/enigma/database/DatenbankSqlite.java
@@ -1,8 +1,6 @@
-package Enigma.model;
+package projekt.enigma.database;
-import javax.swing.text.html.HTML;
import java.sql.*;
-import java.util.Random;
/**
* Dies ist die SQLite Datenbank Klasse
@@ -24,7 +22,7 @@ public class DatenbankSqlite {
*/
private Connection connect() {
- String url = "jdbc:sqlite::resource:Enigma/codebuch.sqlite";
+ String url = "jdbc:sqlite::resource:projekt/enigma/codebuch.sqlite";
Connection conn = null;
try {
@@ -42,36 +40,48 @@ public class DatenbankSqlite {
* Anschließend wir eine Verbindung zur SQLite Datenbank aufgebaut und das Codebuch angefragt.
* Dieses wird in ein Object vom Type Codebuch gepackt und zurück gegeben.
*
+ * Hole den heutigen Eintrag aus der SQLite Datenbank und erstelle daraus ein Codebuch Objekt
+ *
* @param tag : int : Tag für welchen ein Codebuch benötigt wird.
- * @return Codebuch : Codebuch Object mit dem Codebuch des angefragten Tages
+ * @return String : Die Einstellungen des angefragten Tages
+ * <p>
+ * String[0] : Tag
+ * String[1] : Walzenlage
+ * String[2] : Ringstellung
+ * String[3] : Steckverbindung
+ * </p>
*/
- public Codebuch getCodebuch(int tag) throws SQLException {
- Codebuch cb = new Codebuch();
-
- Connection conn = this.connect();
- PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag=? LIMIT 1");
- pstm.setInt(1, tag);
- ResultSet rs = pstm.executeQuery();
-
- while (rs.next()) {
- cb.setTag(rs.getInt("Tag"));
- cb.setWalzenlage(rs.getString("Walzenlage").split(","));
- cb.setRingstellung(rs.getString("Ringstellung").split(","));
- cb.setSteckverbindung(rs.getString("Steckverbindung").split(","));
+ public String[] getCodebuch(int tag) {
+
+ String[] codebuch = new String[4];
+
+ try {
+ Connection conn = this.connect();
+ PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag=? LIMIT 1");
+ pstm.setInt(1, tag);
+ ResultSet rs = pstm.executeQuery();
+
+ while (rs.next()) {
+ codebuch[0] = rs.getString("Tag");
+ codebuch[1] = rs.getString("Walzenlage");
+ codebuch[2] = rs.getString("Ringstellung");
+ codebuch[3] = rs.getString("Steckverbindung");
+ }
+ } catch (SQLException ignored) {
}
- return cb;
+ return codebuch;
}
//region Random New Codebuch generieren
- /*
- *//**
+ /**
* Setzt zufällige Codebuch Einträge in die SQLite Datenbank
* Tag => int
* Walzenlage => String w1,w2,w3
* Ringstellung => String r1,r2,r3
* Steckverbindungen => s0,s1,s2,s3,s4,s5,s6,s7,s8,s9
- *//*
+ */
+ /*
public void autoGenCodebuch() throws SQLException {
Connection conn = connect();
@@ -88,11 +98,12 @@ public class DatenbankSqlite {
conn.commit();
}
- *//**
+ /**
* Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 5)
* die Zahlen sind durch Komma getrennt
* @return String => walzenlage mit drei Kommaseparierten Zufallszahlen zwischen 1 und 5
- *//*
+ */
+ /*
private static String walzenlage(){
String walzenlage;
Random random = new Random();
@@ -105,13 +116,14 @@ public class DatenbankSqlite {
}
walzenlage= w[0]+","+w[1]+","+w[2];
return walzenlage;
- }
+ }*/
- *//**
+ /**
* Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 26)
* die Zahlen sind durch Komma getrennt
* @return String => ringstellung mit drei Kommaseparierten Zufallszahlen zwischen 1 und 26
- *//*
+ */
+ /*
private static String ringstellung(){
String ringstellung;
Random random = new Random();
@@ -121,30 +133,35 @@ public class DatenbankSqlite {
}
ringstellung= w[0]+","+w[1]+","+w[2];
return ringstellung;
- }
+ }*/
- *//**
+ /**
* Generiert einen String aus 10 * 2 unterschiedlichen Großbuchstaben
- * @return String => 10 Buchstabenkombinationen mit Komma getrennt
+ * @return String => 10 Buchstabenkombinationen mit Komma getrennt
*//*
- private static String steckverbindung(){
- Random rnd = new Random();
- String steckverbindung="";
- char[] c = new char[2];
- for (int i = 0; i < 10; i++) {
- for (int j = 0; j < 2; j++) {
- c[j]= (char) (rnd.nextInt(26) + 'A');
- if (j==1) {
- while (c[0] == c[j]) {
- c[j] = (char) (rnd.nextInt(26) + 'A');
- }
- }
- }
- System.out.println(c[0]+" / "+c[1]);
- steckverbindung+= ((""+c[0]) + (""+c[1]) +",");
- }
- steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
- return steckverbindung;
- }*/
+ private static String steckverbindung(){
+ Random rnd = new Random();
+ String steckverbindung="";
+
+
+ char[] c = new char[20];
+ for (int i = 0; i < 20; i++) {
+ c[i] = (char) (rnd.nextInt(26) + 'A');
+ for (int j = i; j >= 0; j--) {
+ if (i>j) {
+ while (c[i]==c[j]) {
+ c[i] = (char) (rnd.nextInt(26) + 'A');
+ j= i-1;
+ }
+ }
+ }
+ }
+ steckverbindung = ((""+c[0]) + (""+c[1]) +"," +(""+c[2]) +(""+c[3]) + ","+(""+c[4]) +(""+c[5]) + ","+(""+c[6]) +(""+c[7]) + ","
+ +(""+c[8]) +(""+c[9]) + ","+(""+c[10]) +(""+c[11]) + ","+(""+c[12]) +(""+c[13]) + ","+(""+c[14]) +(""+c[15]) + ","+(""+c[16]) +(""+c[17]) + ","
+ +(""+c[18]) +(""+c[19]));
+ // System.out.println(steckverbindung);
+ // steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
+ return steckverbindung;
+ }*/
//endregion
}
diff --git a/src/main/java/projekt/enigma/model/Codebuch.java b/src/main/java/projekt/enigma/model/Codebuch.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ded525e6d41617d76f148556b5c8f278bb88a63
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Codebuch.java
@@ -0,0 +1,229 @@
+package projekt.enigma.model;
+
+import projekt.enigma.database.DatenbankSqlite;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+
+/**
+ * Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
+ * Jeder Enigma gehörte auch ein Codebuch bei, welches notwendig war um die Nachrichten zu ver/entschlüsseln.
+ * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
+ * mussten um die Texte zu ver/entschlüsseln.
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
+ * vorgenommen.
+ * Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
+ * festgelegt war.
+ * <p>
+ * Dieses Codebuch Objekt enthält die Einstellungen eines Tages, welche mittels Getter und Setter
+ * verarbeitet werden können.
+ * <p>
+ * Zusätzlich gibt es zu Debug Zwecken eine überschriebene toString Funktion welche das Objekt als String zurück
+ * geben kann.
+ */
+public class Codebuch {
+
+ /**
+ * TODO: Dokumentieren tag
+ * tag : int : gibt den Tag an
+ */
+ private int tag;
+
+ /**
+ * walzenlage : int[] : legt die Positionen der Walzen fest
+ */
+ private int[] walzenlage;
+
+ /**
+ * ringstellung : int[] : TODO ringstellung: char || int ?
+ */
+ private int[] ringstellung;
+
+ /**
+ * steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar
+ */
+ private char[][] steckverbindung;
+
+ /**
+ * Im Konstruktor werden die Standardwerte gesetzt
+ * <p>
+ * walzenlage : int[3] : Hier wird die Position der drei Walzen festgelegt.
+ * ringstellung : char[3] : Jede Walze hat einen Ring. Der Index steht für die Walze und der Value für
+ * die Position des Ringes.
+ * steckverbindung : char[10][] : Zehn Kabel können in das Steckbrett gesteckt werden. In diesem Array werden
+ * die Kabel mit ihren jeweiligen Buchsen hinterlegt.
+ */
+ public Codebuch() {
+ this.walzenlage = new int[3];
+ this.ringstellung = new int[3];
+ this.steckverbindung = new char[10][];
+
+ for (int i = 0; i < 10; i++) {
+ this.steckverbindung[i] = new char[2];
+ this.steckverbindung[i][0] = 'A';
+ this.steckverbindung[i][1] = 'A';
+ }
+ }
+
+ /**
+ * TODO: Dokumentieren
+ * Holt den Tagesschluessel aus dem Codebuch ab. Ist kein Tag angegeben, wird der aktuelle Tag genutzt.
+ * Aus dem Tagesschluessel werden die Werte fuer die Walzenlage, Ringstellung und Steckverbindung
+ * gesetzt.
+ *
+ * @param tag : int[] : gibt einen Tag oder mehrere Tage mit
+ */
+ public void fetchTagesschluessel(int... tag) {
+ String[] walzenlage, ringstellung, db;
+
+ if (tag.length > 0) {
+ db = new DatenbankSqlite().getCodebuch(tag[0]);
+ } else {
+ db = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
+ }
+
+ this.setTag(Integer.parseInt(db[0]));
+
+ walzenlage = db[1].split(",");
+ for (int i = 0; i < 3; i++) {
+ this.setWalzenlage(i, Integer.parseInt(walzenlage[i]));
+ }
+
+ ringstellung = db[2].split(",");
+ for (int i = 0; i < 3; i++) {
+ this.setRingstellung(i, Integer.parseInt(ringstellung[i]));
+ }
+
+ this.setSteckverbindung(db[3].split(","));
+
+ }
+
+ /**
+ * Gibt die aktuelle Instanz des Codebuches als String zurück.
+ * Hierbei werden der Tag die Walzenlagen, Ring-/Grundstellung sowie die Steckverbindungen zurück gegeben.
+ *
+ * @return String : String des gesamten Objektes
+ */
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+
+ // Tag des aktuellen Codebuch Eintrags
+ sb.append("Tag: ").append(this.getTag()).append("\n");
+
+ // In welchem Slot steckt die Walze?
+ sb.append("Walzenlage: ");
+ for (int wl : this.getWalzenlage()) {
+ sb.append(wl).append(",");
+ }
+ if (this.getWalzenlage().length > 0) {
+ sb.setLength(sb.length() - 1);
+ }
+ sb.append("\n");
+
+ // Die Ringstellung an den Walzen
+ sb.append("Ringstellung: ");
+ for (int rs : this.getRingstellung()) {
+ sb.append(rs).append(",");
+ }
+ if (this.getRingstellung().length > 0) {
+ sb.setLength(sb.length() - 1);
+ }
+ sb.append("\n");
+
+ // Das Steckbrett und wie die Kabel angeschlossen sind
+ sb.append("Steckverbindung: ");
+ for (char[] verbindung : this.getSteckverbindung()) {
+ sb.append(verbindung[0]).append(":").append(verbindung[1]).append(",");
+ }
+ if (this.getSteckverbindung().length > 0) {
+ sb.setLength(sb.length() - 1);
+ }
+ sb.append("\n");
+
+ return sb.toString();
+ }
+
+ /**
+ * Gibt den Tag dieser Instanz zurück
+ *
+ * @return int : Tag
+ */
+ public int getTag() {
+ return tag;
+ }
+
+ /**
+ * Setzt den Tag dieser Instanz
+ *
+ * @param tag : int : Tag
+ */
+ void setTag(int tag) { this.tag = tag; }
+
+ /**
+ * Gibt die Walzenlage dieser Instanz zurück
+ *
+ * @return String[] : Walzenlage TODO: String[] || int[]?
+ */
+ public int[] getWalzenlage() {
+ return walzenlage;
+ }
+
+ /**
+ * Gibt die Ringstellung dieser Instanz zurück
+ *
+ * @return String[] : Ringstellung TODO: String[] || int[]?
+ */
+ public int[] getRingstellung() {
+ return ringstellung;
+ }
+
+ /**
+ * Gibt die Steckverbindung dieser Instanz zurück
+ *
+ * @return String[] : Steckverbindung
+ */
+ // TODO
+ public char[][] getSteckverbindung() {
+ return this.steckverbindung;
+ }
+
+ /**
+ * Setzt die Steckverbindung dieser Instanz
+ *
+ * @param kabel : String[] : Die Steckverbindungen die gesteckt werden sollen.
+ * Jeder Eintrag im Array ist ein String mit zwei Zeichen.
+ * Diese werden in zwei chars zerlegt und anschließend im globalen
+ * Array gespeichert.
+ */
+ private void setSteckverbindung(String[] kabel) {
+ int counter = 0;
+
+ for (String stecker : kabel) {
+ char[] verbindung = new char[2];
+ verbindung[0] = stecker.charAt(0);
+ verbindung[1] = stecker.charAt(1);
+ this.steckverbindung[counter++] = verbindung;
+ }
+ }
+
+ /**
+ * Setzt die Walzenlage dieser Instanz
+ *
+ * @param position : int : Position der Walze
+ * @param walzenlage : int : Welche Walze wurde eingesetzt
+ */
+ private void setWalzenlage(int position, int walzenlage) {
+ this.walzenlage[position] = walzenlage;
+ }
+
+ /**
+ * Setzt die Ringstellung dieser Instanz
+ *
+ * @param position : int : Auf welche Walze wird der Ring aufgesetzt?
+ * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]?
+ */
+ private void setRingstellung(int position, int ringstellung) {
+ this.ringstellung[position] = ringstellung;
+ }
+}
diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
new file mode 100644
index 0000000000000000000000000000000000000000..724cb462b9b6034bd2544aed4bd3446ebb7b1d0d
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -0,0 +1,476 @@
+package projekt.enigma.model;
+
+import org.apache.http.HttpException;
+
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Random;
+
+/**
+ * Die Codierer Klasse beschreibt den Benutzer welcher die Enigma benutzt.
+ * Alle Vorgänge wie z.B. das zusammenbauen der Hardware, auslesen des Codebuches und das anschließende codieren,
+ * finden hier statt. Dieser ist quasi die Schnittstelle zwischen der GUI (Hauptmann welcher ihm sagt was er zu
+ * verschlüsseln hat), der Enigma und dem Funker im Funkraum, welcher die Nachricht im Anschluß versendet.
+ */
+public class Codierer {
+
+ /**
+ * Der Klartext Spruchschlüssel zur codierung der Nachricht
+ */
+ private String spruchschluessel;
+ /**
+ * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert
+ */
+ private String spruchschluesselCodiert;
+ /**
+ * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum)
+ */
+ private String kenngruppe;
+ /**
+ * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert
+ * und im laufe der Benutzung ergänzt
+ */
+ private String nachricht;
+ /**
+ * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet.
+ */
+ private Hardware hardware;
+ /**
+ * Im Codebuch sind die Tageswerte zu finden. Ãœber dieses Objekt kann darauf zugegriffen werden.
+ */
+ private Codebuch codebuch;
+ /**
+ * Der aktuelle Tagesschluessel. Dieser wird aus dem Codebuch ausgelesen und hier hinterlegt.
+ */
+ private String tagesSchluessel;
+
+ /**
+ * Der Konstruktor des Codierers
+ * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert.
+ */
+ public Codierer() {
+
+ this.nachricht = "";
+ this.spruchschluessel = "";
+ this.spruchschluesselCodiert = "";
+ this.kenngruppe = "";
+ this.codebuch = new Codebuch();
+ this.codebuch.fetchTagesschluessel();
+ }
+
+ /**
+ * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
+ * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
+ * in die Hardware gebaut.
+ * <br>
+ * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
+ * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
+ * <br>
+ * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
+ * Codebuch Eintrag.
+ */
+ private void initialisiereHardware() {
+
+ // Das Steckbrett initialisieren
+ Steckbrett sb = new Steckbrett();
+ char[][] verbinder = this.codebuch.getSteckverbindung();
+
+ // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
+ for (char[] kabel : verbinder) {
+ sb.setzeVertauschung(kabel[0], kabel[1]);
+ }
+
+ // Die Hardware aus dem Koffer holen (initialisieren)
+ this.hardware = new Hardware();
+
+ // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
+ this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]);
+ this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]);
+ this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]);
+
+ // Der Hardware das gesetzte Steckbrett zuweisen
+ this.hardware.setSteckbrett(sb);
+
+ // Ein Reflektor Objekt erstellen und der Hardware bekannt geben
+ this.hardware.setReflektor(new Reflektor());
+
+ }
+
+ /**
+ * Hier wird ein neuer Spruchschlüssel generiert.
+ * <p>
+ * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
+ * Tagesschlüssel codiert, hinzugefügt.
+ * <br>
+ * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert,
+ * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist.
+ * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt.
+ * <br>
+ * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat.
+ */
+ public void generateSpruchschluessel() {
+
+ String klartext = "";
+
+ while (klartext.length() < 3) {
+ String temp = this.randomBuchstabe();
+ if (!klartext.contains(temp)) {
+ klartext += temp;
+ }
+ }
+
+ this.spruchschluessel = klartext;
+ this.spruchschluesselCodiert = this.codiere(klartext + klartext, false);
+
+ // Walzen auf den Spruchschlüssel stellen
+ this.hardware.setzePosition(0, this.spruchschluessel.charAt(0));
+ this.hardware.setzePosition(1, this.spruchschluessel.charAt(1));
+ this.hardware.setzePosition(2, this.spruchschluessel.charAt(2));
+
+ // Die Kenngruppe codieren und in der Nachricht speichern
+ this.codiere(this.kenngruppe, true);
+ }
+
+ /**
+ * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
+ * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
+ *
+ * @return String : Der klartext Spruchschlüssel
+ */
+ public String getSpruchschluessel() {
+ return this.spruchschluessel;
+ }
+
+ /**
+ * Erstellen des Nachrichten Kopfes.
+ * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den
+ * Tagescodes codierte, Spruchschlüssel.
+ */
+ private String generateKopf() {
+ Calendar cal = Calendar.getInstance();
+
+ // Uhrzeit an den Kopf hängen
+ return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " +
+
+ // Zeichen Anzahl der Nachricht
+ this.nachricht.length() + " " +
+
+ // Spruchschlüssel anhängen
+ this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " ";
+ }
+
+ /**
+ * Einen zufälligen Buchstaben aus dem Alphabet generieren.
+ * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind.
+ * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben.
+ *
+ * @return String : ein zufällig generierter Buchstabe
+ */
+ private String randomBuchstabe() {
+ return String.valueOf((char) ('A' + new Random().nextInt(26)));
+ }
+
+ /**
+ * Befehl die Nachricht an den Funker zu übergeben
+ *
+ * @throws IOException : Die Antwort konnte nicht gelesen werden
+ * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
+ */
+ public void sendeNachricht() throws IOException, HttpException {
+ String kopf = this.generateKopf();
+ new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
+ this.nachricht = "";
+ }
+
+ /**
+ * Gibt die letzte empfangene Nachricht zurück
+ * <br>
+ * String[0] Tag wann die Nachricht gesendet wurde
+ * String[1] = Die verschlüsselte Nachricht
+ * String[2] = Nachricht im Klartext
+ */
+ public String[] empfangeNachricht() {
+
+ this.nachricht = "";
+ Morsecode mc = new Morsecode();
+ String[] nachricht = new String[4];
+ String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+
+ if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
+ nachricht[0] = codierteNachricht[0];
+ nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+ nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
+ StringBuilder sb = new StringBuilder();
+
+ sb.append(nachricht[1], 0, 16);
+ for (int i = 17; i <= nachricht[1].length(); ) {
+ if ((i + 5) < nachricht[1].length()) {
+ sb.append(nachricht[1], i, i + 5).append(" ");
+ i += 5;
+ } else {
+ sb.append(nachricht[1].substring(i));
+ break;
+ }
+ }
+ nachricht[1] = sb.toString();
+ } else {
+ nachricht[0] = "";
+ nachricht[1] = "";
+ nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
+ }
+
+ return nachricht;
+ }
+
+ /**
+ * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
+ * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
+ *
+ * @return String : Kenngruppe
+ */
+ public String getKenngruppe() {
+ return kenngruppe;
+ }
+
+ /**
+ * Setzt die Kenngruppe welche die Enigma gerade benutzt.
+ *
+ * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
+ */
+ public void setKenngruppe(String kenngruppe) {
+
+ this.kenngruppe = kenngruppe;
+ this.initialisiereHardware();
+
+ }
+
+ /**
+ * Gibt die bisher erstellte Nachricht zurück
+ *
+ * @return String : Erstellte Nachricht
+ */
+ public String getNachricht() {
+ return nachricht;
+ }
+
+ /**
+ * Gibt die aktuellen Buchstaben auf den Walzen zurück
+ *
+ * @return char[] : Walzen Array mit der aktuellen Position
+ */
+ public char[] getWalzen() {
+ char[] walzen = new char[3];
+ walzen[0] = this.hardware.getWalzen()[0].getPosition();
+ walzen[1] = this.hardware.getWalzen()[1].getPosition();
+ walzen[2] = this.hardware.getWalzen()[2].getPosition();
+
+ return walzen;
+ }
+
+ /**
+ * Hier wird ein einzelner Buchstabe verschlüsselt.
+ * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+ * In der Regel ist dies der Fall.
+ *
+ * @param buchstabe : char : Der zu codierende Buchstabe
+ * @param save : boolean : Nachricht speichern oder nicht
+ * @return char : Der codierte Buchstabe
+ */
+ public char codiere(char buchstabe, boolean save) {
+ char codiert = this.hardware.codiere(buchstabe);
+ if (save) {
+ this.nachricht += codiert;
+ }
+
+ return codiert;
+ }
+
+ /**
+ * Codiert den Ãœbergebenen String.
+ * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+ * In der Regel ist dies der Fall.
+ *
+ * @param klartext : String : Der zu codierende Text
+ * @param save : boolean : Nachricht speichern oder nicht
+ * @return String : Der codierte Text zusätzlich als Rückgabe
+ */
+ public String codiere(String klartext, boolean save) {
+
+ StringBuilder sb = new StringBuilder();
+
+ for (char buchstabe : klartext.toCharArray()) {
+ sb.append(this.codiere(buchstabe, save));
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht.
+ * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum.
+ * In der Regel ist dies der Tag des Nachrichten empfangs.
+ *
+ * @param codierteNachricht : String : Enigma codierte Nachricht
+ * @param tag : int : Tag der Nachricht
+ * @return String : decodierte Nachricht
+ */
+ private String decodiere(String codierteNachricht, int tag) {
+
+ // Hardware reseten und Tageseinstellungen aus dem Codebuch laden
+ this.initialisiereHardware();
+ this.codebuch.fetchTagesschluessel(tag);
+
+ String[] nachricht = codierteNachricht.split(" ");
+ StringBuilder sb = new StringBuilder();
+
+ // Uhrzeit
+ sb.append(nachricht[0]).append(" ");
+
+ // Zeichen Anzahl der Nachricht
+ sb.append(nachricht[1]).append(" ");
+
+ // Spruchschlüssel
+ String spruchschluessel = this.decodiereString(nachricht[2]);
+ sb.append(spruchschluessel).append(" ");
+ sb.append(this.decodiereString(nachricht[3])).append(" ");
+
+ // Walzen neu einstellen mit dem Spruchschlüssel
+ this.hardware.setzePosition(0, spruchschluessel.charAt(0));
+ this.hardware.setzePosition(1, spruchschluessel.charAt(1));
+ this.hardware.setzePosition(2, spruchschluessel.charAt(2));
+
+ // Nachricht decodieren
+ sb.append(this.decodiereString(nachricht[4]));
+
+ return sb.toString();
+ }
+
+ /**
+ * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen.
+ * Der String wird dann decodiert zurück gegeben.
+ *
+ * @param nachricht : String : Der zu decodierende Text
+ * @return String : Der decodierte Text
+ */
+ private String decodiereString(String nachricht) {
+
+ StringBuilder sb = new StringBuilder();
+
+ for (char buchstabe : nachricht.toCharArray()) {
+ if (buchstabe > 0) {
+ sb.append(this.hardware.codiere(buchstabe));
+ }
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
+ */
+ public void resetHardware() {
+ this.initialisiereHardware();
+ }
+
+ /**
+ * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
+ * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
+ *
+ * @param walzenPosition : int : Nummer der Walze
+ * @param buchstabe : char : Buchstabe der zugewiesen soll
+ */
+ public void setWalze(int walzenPosition, char buchstabe) {
+ this.hardware.setzePosition(walzenPosition, buchstabe);
+ }
+
+ /**
+ * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
+ *
+ * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
+ * @param umsprungPunkt : int : Buchstabe auf dem der Notch sitzt
+ */
+ public void setRing(int walzenPosition, int umsprungPunkt) {
+ this.hardware.setzeRing(walzenPosition, umsprungPunkt);
+ }
+
+ /**
+ * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
+ * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
+ *
+ * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
+ * @param walzeNr : int : Nummer der Walze die eingesetzt wird
+ * @param ringstellung : int : Stellung des Ringes
+ */
+ public void setWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
+ this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
+ }
+
+ /**
+ * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
+ *
+ * @param port : int : Kabel Nummer welches am Steckbrett eingesteckt wird
+ * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
+ * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
+ */
+ public boolean setSteckbrett(int port, String verbindung) {
+ return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
+ }
+
+ /**
+ * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
+ * <p>
+ * setSteckbrett ausführen mit beiden Buchstaben als String
+ *
+ * @param buchstabe : char : Der zuletzt eingegebene Buchstabe
+ * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false
+ */
+ public boolean pruefeSteckbrettPort(char buchstabe) {
+ return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe);
+ }
+
+ /**
+ * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück.
+ *
+ * @param empfangeneNachricht : String : Die empfangene Nachricht als String
+ * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde.
+ */
+ public String empfangenerSpruchschluessel(String empfangeneNachricht) {
+ String[] nachricht = empfangeneNachricht.split(" ");
+
+ return nachricht[2];
+ }
+
+ /**
+ * Gibt die Ringstellungen aus dem Codebuch zurück
+ *
+ * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
+ */
+ public int[] fetchRingstellung() {
+ return this.codebuch.getRingstellung();
+ }
+
+ /**
+ * Gibt die Walzennummer aus dem Codebuch zurück
+ *
+ * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
+ */
+ public int[] getchWalzenNr() {
+ return this.codebuch.getWalzenlage();
+ }
+
+ /**
+ * Gibt die Steckverbindungen aus dem Codebuch zurück
+ *
+ * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
+ */
+ public char[][] getSteckverbindungen() {
+ return this.codebuch.getSteckverbindung();
+ }
+
+ /**
+ * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+ */
+ public void letztesZeichenLoeschen() {
+ this.hardware.dreheWalzen(-1);
+ }
+}
diff --git a/src/main/java/Enigma/model/Funkraum.java b/src/main/java/projekt/enigma/model/Funkraum.java
similarity index 62%
rename from src/main/java/Enigma/model/Funkraum.java
rename to src/main/java/projekt/enigma/model/Funkraum.java
index de283e750d219646a8fbca82f81626a4b94dff0d..96a3a35b3fa9391afad8d5193ff4923bb368c391 100644
--- a/src/main/java/Enigma/model/Funkraum.java
+++ b/src/main/java/projekt/enigma/model/Funkraum.java
@@ -1,4 +1,4 @@
-package Enigma.model;
+package projekt.enigma.model;
import org.apache.http.HttpEntity;
import org.apache.http.HttpException;
@@ -10,6 +10,7 @@ import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.json.JSONObject;
+
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
@@ -25,39 +26,46 @@ import java.util.List;
* (Benutzername) übergeben und falls eine Nachricht gesendet werden soll, zusätzlich ein m mit der Nachricht.
* Beides wird als String gesendet.
*/
-public class Funkraum {
+class Funkraum {
/**
* Zum Empfangen liefert der Server, anstatt der Kenngruppe (k) den Empfangstag der Nachricht mit damit man
- * die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
- * {'m': 'Hello world', 't': '26'}
+ * die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
+ * {'m': 'Hello world', 't': '26'}
*
* @param kenngruppe : String : Kenngruppe dieser Engiam
* @return String[] : String Array wobei Index 0 dem Empfangstag entspricht und index 1 der empfangenen Nachricht
- * @throws IOException : Exception : wenn keine Verbindung zum Funker aufgebaut werden konnte.
*/
- public String[] empfangeFunkspruch(String kenngruppe) throws IOException {
+ String[] empfangeFunkspruch(String kenngruppe) {
+
String[] funkspruch = new String[2];
HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
- // Anfrage Parameter und Encoding setzen
- List<NameValuePair> params = new ArrayList<>(2);
- params.add(new BasicNameValuePair("k", kenngruppe));
- httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
+ try {
+ // Anfrage Parameter und Encoding setzen
+ List<NameValuePair> params = new ArrayList<>(2);
+ params.add(new BasicNameValuePair("k", kenngruppe));
+ httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
- // POST Request ausführen und Rückgabe verarbeiten
- HttpResponse response = httpclient.execute(httppost);
- HttpEntity entity = response.getEntity();
+ // POST Request ausführen und Rückgabe verarbeiten
+ HttpResponse response = httpclient.execute(httppost);
+ HttpEntity entity = response.getEntity();
- if (entity != null) {
- BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
- JSONObject result = new JSONObject(reader.readLine());
+ if (entity != null) {
+ BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
+ JSONObject result = new JSONObject(reader.readLine());
- if(!result.getString("m").isEmpty()) {
- funkspruch[0] = result.getString("t");
- funkspruch[1] = result.getString("m");
+ if (!result.getString("m").isEmpty()) {
+ funkspruch[0] = result.getString("t");
+ funkspruch[1] = result.getString("m");
+ }
}
+ } catch (UnsupportedEncodingException e) {
+ System.out.println("Encoding wird nicht unterstützt.");
+ } catch (IOException e) {
+ System.out.println("HTTP Post war nicht erfolgreich.\nBitte wenden Sie sich an ihren Vorgesetzten.");
+ e.printStackTrace();
}
return funkspruch;
@@ -67,19 +75,20 @@ public class Funkraum {
* Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
* Dieser nimmt die Daten entgegeb und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
* irgendwann, auf Anfrage, wieder abgerufen werden können.
- *
- * Darauf antworter der Server dann mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
- * {'result': 200}
- *
- * Die 200 heißt hier das alles erfolgreich durchgeführt 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 später erneut versucht.
+ * <p>
+ * Darauf antworter der Server dann mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
+ * {'result': 200}
+ * <p>
+ * Die 200 heißt hier das alles erfolgreich durchgeführt 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 später erneut versucht.
*
* @param funkspruch : String : Der zu sendede Funkspruch
* @param kenngruppe : String : Die Kenngruppe dieser Engima
* @throws IOException : Exception : Funkspruch konnte nicht gesendet werden
*/
- public void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
+ void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
+
HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
@@ -96,7 +105,7 @@ public class Funkraum {
if (entity != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
JSONObject result = new JSONObject(reader.readLine());
- if(result.getInt("result") != 200) {
+ if (result.getInt("result") != 200) {
throw new HttpException("Der andere Funker mag deine Nachricht nicht. Rüge ihn wenn du ihn wieder siehst...");
}
}
diff --git a/src/main/java/projekt/enigma/model/Hardware.java b/src/main/java/projekt/enigma/model/Hardware.java
new file mode 100644
index 0000000000000000000000000000000000000000..58ac07827ed796bc9bfa9605f9b8c1bfe31dff84
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Hardware.java
@@ -0,0 +1,175 @@
+package projekt.enigma.model;
+
+/**
+ * In dieser Klasse wird die Hardware zusammen gefasst.
+ * Alle Komponenter 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
+ * kenngruppe : String : Früher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
+ * Wir missbrauchen die Kenngruppe für einen Benutzernamen
+ * </p>
+ */
+public class Hardware {
+
+ /**
+ * TODO: Dokumentieren
+ */
+ private Walze[] walzen;
+ private Steckbrett steckbrett;
+ private Reflektor reflektor;
+
+ /**
+ * 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.
+ */
+ public Hardware() {
+ this.walzen = new Walze[3];
+ }
+
+ /**
+ * Setzt eine Walze ein
+ *
+ * @param walze : int : Setzt die Walze mit der angegebenen Nummer ein
+ * @param walzenNr : int : Die Nummer der einzusetzenden Walze
+ */
+ public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
+ this.walzen[walze] = new Walze(walzenNr, ringstellung);
+ }
+
+ /**
+ * Setzt den Notch der Walze
+ *
+ * @param walze : int : Position 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)
+ *
+ * @param walze : int : Nummer der Walze
+ * @param buchstabe : char : Buchstabe der zugewiesen 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
+ *
+ * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
+ * @return char : Der ver/entschlüsselte Buchstabe
+ */
+ public char codiere(char buchstabe) {
+ this.dreheWalzen(1);
+
+ buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
+ buchstabe = this.walzen[2].codiere(buchstabe);
+ buchstabe = this.walzen[1].codiere(buchstabe);
+ buchstabe = this.walzen[0].codiere(buchstabe);
+ buchstabe = this.reflektor.codiere(buchstabe);
+ buchstabe = this.walzen[0].codiere2(buchstabe);
+ buchstabe = this.walzen[1].codiere2(buchstabe);
+ buchstabe = this.walzen[2].codiere2(buchstabe);
+ buchstabe = this.steckbrett.codiere(buchstabe);
+
+ return buchstabe;
+ }
+
+ /**
+ * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
+ * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
+ */
+ public void dreheWalzen(int richtung) {
+ if (richtung > 0) {
+ for (int i = 0; i < richtung; i++) {
+ if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) {
+ this.walzen[0].dreheWalze(1);
+ }
+ }
+ } else {
+ for (int i = 0; i > richtung; richtung++) {
+ if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) {
+ this.walzen[0].dreheWalze(-1);
+ }
+ }
+ }
+ }
+
+ /**
+ * Gibt die verbauten Walzen Objekte zurück
+ *
+ * @return Walze[] : Array mit den Walzen Objekten
+ */
+ public Walze[] getWalzen() {
+ return this.walzen;
+ }
+
+ /**
+ * Setzt eine Walze ein und speichert das Objekt im Walzen Array
+ *
+ * @param position : int : Position der Walze
+ * @param walze : int : Die Nummer der Walze
+ * @param ringstellung : int : Umsprung Punkt 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
+ *
+ * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
+ */
+ public Steckbrett getSteckbrett() {
+ return steckbrett;
+ }
+
+ /**
+ * Setzt das übergebene Steckbrett Objekt in die Hardware ein
+ *
+ * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
+ */
+ public void setSteckbrett(Steckbrett steckbrett) {
+ this.steckbrett = steckbrett;
+ }
+
+ /**
+ * Liest den Reflektor aus und gibt ihn zurück
+ *
+ * @return Reflektor : Objekt des Reflektors
+ */
+ public Reflektor getReflektor() {
+ return reflektor;
+ }
+
+ /**
+ * Setzt den Reflektor ein.
+ * 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,
+ * welches ausgetauscht werden kann.
+ *
+ * @param reflektor : Reflektor : Das Obejtk des Reflektors
+ */
+ public void setReflektor(Reflektor reflektor) {
+ this.reflektor = reflektor;
+ }
+
+ /**
+ * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück.
+ * Hierfür ist der Buchstabe "A" festgelegt.
+ * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen.
+ */
+ public void resetWalzen() {
+ this.getWalzen()[0].setPosition('A');
+ this.getWalzen()[1].setPosition('A');
+ this.getWalzen()[2].setPosition('A');
+ }
+
+}
diff --git a/src/main/java/Enigma/model/Morsecode.java b/src/main/java/projekt/enigma/model/Morsecode.java
similarity index 91%
rename from src/main/java/Enigma/model/Morsecode.java
rename to src/main/java/projekt/enigma/model/Morsecode.java
index f8c759cf70fd7d17b2024ce91077b5835c46c618..7d99652547325b95631bb82dc8216ff4bdf5bc25 100644
--- a/src/main/java/Enigma/model/Morsecode.java
+++ b/src/main/java/projekt/enigma/model/Morsecode.java
@@ -1,4 +1,4 @@
-package Enigma.model;
+package projekt.enigma.model;
import java.util.*;
import java.util.Map.Entry;
@@ -42,6 +42,17 @@ public class Morsecode {
this.codeMap.put("X", "-..-");
this.codeMap.put("Y", "-.--");
this.codeMap.put("Z", "--..");
+ this.codeMap.put(" ", "-...-");
+ this.codeMap.put("1", ".----");
+ this.codeMap.put("2", ".----");
+ this.codeMap.put("3", "...--");
+ this.codeMap.put("4", "....-");
+ this.codeMap.put("5", ".....");
+ this.codeMap.put("6", "-....");
+ this.codeMap.put("7", "--...");
+ this.codeMap.put("8", "---..");
+ this.codeMap.put("9", "----.");
+ this.codeMap.put("0", "-----");
}
/**
@@ -93,7 +104,6 @@ public class Morsecode {
*/
private String getBuchstabe(String morsecode) {
// Initialisieren des Rückgabe Strings
- // TODO: Darf bei der Initialisierung gleich einen Wert setzten lauf JAVA Konventionen?
String result = null;
// Loopt duch die Codemap und erstellt daraus ein Set
@@ -124,14 +134,13 @@ public class Morsecode {
String[] morsecodes = input.split(" ");
-
// Durch alle char im übergebenen String loopen
for(String morsecode : morsecodes) {
// Wenn der char in der codeMap enthalten ist, an den Rückgabe String anheften, ansonsten nichts ignorieren.
buchstabe = this.getBuchstabe(morsecode);
if(buchstabe != null) {
- sb.append(buchstabe).append(' ');
+ sb.append(buchstabe);
}
}
diff --git a/src/main/java/projekt/enigma/model/Reflektor.java b/src/main/java/projekt/enigma/model/Reflektor.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e5e6b1424852c8ee063179f8a8d216aac9c969a
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Reflektor.java
@@ -0,0 +1,48 @@
+package projekt.enigma.model;
+
+/**
+ * Klasse Reflektor
+ * <br>
+ * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
+ * Der kodierte Buchstabe wird an die Klasse Walze wieder zurückgegeben.
+ * <br>
+ * Prinzipiell verhält sich die Klasse Reflektor wie die Klasse Walze, außer das sie sich
+ * nach Betätigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
+ * an andere Walzen zum drehen.
+ */
+public class Reflektor {
+
+ /**
+ * WALZE_ALPHABET : konstanter Char-Array mit den Werten des Alphabeths (26 Werte)
+ */
+ private final Character[] WALZE_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'};
+
+ /**
+ * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte)
+ */
+ private final Character[] WALZE_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'};
+
+
+ /**
+ * Funktion codiere
+ * <br>
+ * Durchsucht das konstante Char-Array WALZE_ALPHABET nach der Position eines bestimmten
+ * Buchstabens und gibt den Character an der entsprechenden Position im konstanten
+ * Char-Array WALZE_REFLEKTOR zurück.
+ *
+ * @return WALZE_REFLEKTOR[iPositionReflektor]: Character: Der kodierte Buchstabe aus dem Reflektor
+ */
+ public char codiere(Character buchstabe) {
+ int iPositionReflektor = 0;
+
+ //Ermittelt die Position des Buchstaben "buchstabe" auf der Alphabetswalze
+ for (int index = 0; index < WALZE_ALPHABET.length; index++) {
+ if (buchstabe.equals(WALZE_ALPHABET[index])) {
+ iPositionReflektor = index;
+ break;
+ }
+ }
+
+ return WALZE_REFLEKTOR[iPositionReflektor];
+ }
+}
diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec18c7ae9aed17c12a2bd361eda796f0c6cb5497
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -0,0 +1,142 @@
+package projekt.enigma.model;
+
+/**
+ * Klasse Steckbrett
+ * <br>
+ * 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 {
+
+ /**
+ * zaehler: Int, der als Laufvariable für die gesteckten Kabel genutzt wird
+ */
+ private int zaehler;
+
+ /**
+ * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
+ */
+ private Character[] orginalBuchstaben;
+
+ /**
+ * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
+ */
+ private Character[] getauschteBuchstaben;
+
+
+ /**
+ * Konstruktor Steckbrett
+ * <br>
+ * Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
+ */
+ public Steckbrett() {
+
+ orginalBuchstaben = new Character[10];
+ getauschteBuchstaben = new Character[10];
+ }
+
+ /**
+ * Funktion setzeVertauschung
+ * <br>
+ * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
+ * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+ * <br>
+ * Anschließend wird:
+ * <p>
+ * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
+ * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index 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
+ */
+ public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
+
+ if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && (zaehler < orginalBuchstaben.length)) {
+ orginalBuchstaben[zaehler] = buchstabe1;
+ getauschteBuchstaben[zaehler++] = buchstabe2;
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Funktion setzeVertauschung mit angabe eines Ports von 1 - 10
+ * <br>
+ * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port übergeben.
+ * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+ * <br>
+ * Anschließend wird:
+ * <p>
+ * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
+ * buchstabe2 in das Array getauschteBuchstaben auf den Index (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
+ */
+ public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
+
+ if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
+ orginalBuchstaben[steckbrettPort - 1] = buchstabe1;
+ getauschteBuchstaben[steckbrettPort - 1] = buchstabe2;
+
+ return true;
+ } else {
+
+ return false;
+ }
+
+ }
+
+ /**
+ * Funktion ueberpruefeVertauschungen
+ * <br>
+ * Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays
+ * (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist.
+ * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
+ * (ein Buchstabe nicht mehrmals vertauscht wird).
+ *
+ * @return boolean : Wenn false, dann darf der Buchstabe genutzt werden.
+ * Wenn er schon vorhanden ist, wird true zurück gegeben
+ */
+ public boolean ueberpruefeVertauschungen(Character buchstabe) {
+
+ boolean result = false;
+
+ for (int n = 0; n < orginalBuchstaben.length; n++) {
+ if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
+ result = true;
+ break;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Funktion codiere
+ * <br>
+ * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
+ *
+ * @param buchstabe : Character : Buchstabe der codiert werden soll.
+ * @return buchstabe : Character : Codierter Buchstabe.
+ */
+ public char codiere(Character buchstabe) {
+ for (int index = 0; index < getauschteBuchstaben.length; index++) {
+ if (buchstabe.equals(getauschteBuchstaben[index])) {
+ buchstabe = orginalBuchstaben[index];
+ } else if (buchstabe.equals(orginalBuchstaben[index])) {
+ buchstabe = getauschteBuchstaben[index];
+ }
+ }
+
+ return buchstabe;
+ }
+
+}
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
new file mode 100644
index 0000000000000000000000000000000000000000..99d41248aa3aca3a3529674c1750a79c4ebe8a3a
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -0,0 +1,244 @@
+package projekt.enigma.model;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * Klasse Walze
+ * <br>
+ * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
+ * <br>
+ * 1. Walzennummer (Die Walze enthält die 26 Buchstaben des Alphabeths und codiert diese.
+ * 5 verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabeths
+ * paarweise vertauschen)
+ * <br>
+ * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
+ * den Drehzeitpunkt der linken Nachbarwalze)
+ */
+public class Walze {
+
+ /**
+ * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+ */
+ private Character[] alphabet;
+
+ /**
+ * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
+ */
+ private char ringstellung;
+
+ /**
+ * walzennr : int : Bestimmt, welche Walze genutzt wird
+ */
+ private int walzennr;
+
+ /**
+ * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
+ * aber immer wieder ueberschrieben.
+ */
+ private Character[] walzeAlpha;
+
+ /**
+ * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
+ *
+ * @param walzennr : int : Nummer der gewaehlten Walze
+ * @param ringstellung : int : Einstellung des Umsprungpunktes
+ */
+ public Walze(int walzennr, int ringstellung) {
+ this.alphabet = new Character[]{'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'};
+ this.walzeAlpha = new Character[]{'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'};
+
+ this.setWalzennr(walzennr);
+ this.setRingstellung(ringstellung);
+ }
+
+ /**
+ * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
+ *
+ * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+ */
+ private Character[] walzenNummer() {
+ Character[] walze = new Character[26];
+
+ // Character-Arrays fuer die Codierung jeder Walze
+ Character[] walzeEins = {'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'};
+ Character[] walzeZwei = {'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'};
+ Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y',
+ 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+ Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X',
+ 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+ Character[] walzeFuenf = {'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'};
+
+ switch (this.walzennr) {
+ case 1:
+ walze = walzeEins;
+ break;
+ case 2:
+ walze = walzeZwei;
+ break;
+ case 3:
+ walze = walzeDrei;
+ break;
+ case 4:
+ walze = walzeVier;
+ break;
+ case 5:
+ walze = walzeFuenf;
+ break;
+ }
+
+ return walze;
+ }
+
+ /**
+ * TODO: Dokumentieren
+ *
+ * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
+ */
+ public char getRingstellung() {
+ return ringstellung;
+ }
+
+ /**
+ * Setzt die Initiale Ringstellung der Walze.
+ * Es sind nur Zahlen von 1 - 26 zugelassen.
+ * <p>
+ * Die Ringstellung wird zum char umgewandelt.
+ * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+ *
+ * @param ringstellung : int : Punkt an dem die Walze umspringt
+ */
+ //TODO ??? Setter Ringstellung
+ public void setRingstellung(int ringstellung) {
+ if ((ringstellung > 0) && (ringstellung <= 26)) {
+ this.ringstellung = this.alphabet[ringstellung - 1];
+ } else {
+ this.ringstellung = 'Z';
+ }
+ }
+
+ /**
+ * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
+ * das Array alphabet mit der neuen Anordnung.
+ * <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 zurück
+ * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
+ * TODO: Doku
+ */
+ public boolean dreheWalze(int richtung) {
+ boolean checkRing = false;
+ int korrektorFaktor = 0;
+
+ if (richtung == 1) {
+ Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
+ } else {
+ korrektorFaktor = 1;
+ Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
+ }
+
+ // gleicht die Ringstellung mit der aktuellen Position ab
+ if (this.getPosition() + korrektorFaktor == this.ringstellung) {
+ checkRing = true;
+ }
+
+ return checkRing;
+ }
+
+ /**
+ * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
+ *
+ * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
+ * @return buchstabe : char : verschluesselter Buchstabe
+ */
+ public char codiere(char buchstabe) {
+ /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
+ uebertraegt den Index auf die gewaehlte Codierwalze*/
+ buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
+
+ return buchstabe;
+ }
+
+ /**
+ * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
+ *
+ * @param buchstabe : char : Buchstabe, der decodiert werden soll
+ * @return buchstabe : char : decodierter Buchstabe
+ */
+ public char codiere2(char buchstabe) {
+ /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
+ uebertraegt den Index auf die (verschobene) Alphabetswalze*/
+ buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())];
+
+ return buchstabe;
+ }
+
+ /**
+ * TODO: Dokumentieren
+ * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
+ *
+ * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
+ * @param array : Character[] : Array, in dem der Buchstabe vorkommen soll
+ * @return result : int : index des Buchstaben
+ */
+ private int fetchArrayIndex(Character buchstabe, Character[] array) {
+ // wird mit ungueltigem Wert initialisiert
+ int result = -1;
+
+ for (int i = 0; i < array.length; i++) {
+ if (array[i].equals(buchstabe)) {
+ result = i;
+ break;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
+ *
+ * @param walzennr : int : Walzennummer
+ */
+ public void setWalzennr(int walzennr) {
+ if ((walzennr > 0) && (walzennr < 6)) {
+ this.walzennr = walzennr;
+ } else {
+ System.err.println("Keine gültige Walzennummer");
+ }
+ }
+
+ /**
+ * TODO: Dokumentieren // das selbe wie getAnzeig?
+ * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
+ *
+ * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+ */
+ public Character getPosition() {
+ return walzeAlpha[0];
+ }
+
+ /**
+ * * TODO: Funktionsname hat sich geändert
+ * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+ * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+ * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+ *
+ * @param buchstabe : Character : Einstellung der Walze
+ */
+ public void setPosition(Character buchstabe) {
+ if (Character.isLetter(buchstabe)) {
+ buchstabe = Character.toUpperCase(buchstabe);
+ System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
+ if (buchstabe > 'A') {
+ dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
+ }
+ }
+ }
+}
diff --git a/src/main/resources/Enigma/gui.fxml b/src/main/resources/Enigma/gui.fxml
deleted file mode 100644
index ae2b648dd67c8856ee83f5a43d166affc882a42a..0000000000000000000000000000000000000000
--- a/src/main/resources/Enigma/gui.fxml
+++ /dev/null
@@ -1,200 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.scene.control.Button?>
-<?import javafx.scene.control.ButtonBar?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.MenuButton?>
-<?import javafx.scene.control.MenuItem?>
-<?import javafx.scene.control.TextField?>
-<?import javafx.scene.layout.AnchorPane?>
-
-<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="677.0" prefWidth="967.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="Enigma.GuiController">
- <children>
- <TextField layoutX="43.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="112.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="187.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="272.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="346.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="413.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="476.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="544.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="617.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <TextField layoutX="693.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
- <ButtonBar layoutX="31.0" layoutY="570.0" prefHeight="36.0" prefWidth="860.0">
- <buttons>
- <Button mnemonicParsing="false" text="L" />
- <Button mnemonicParsing="false" text="P" />
- <Button mnemonicParsing="false" text="Y" />
- <Button mnemonicParsing="false" text="X" />
- <Button mnemonicParsing="false" text="C" />
- <Button mnemonicParsing="false" text="V" />
- <Button mnemonicParsing="false" text="B" />
- <Button mnemonicParsing="false" text="N" />
- <Button mnemonicParsing="false" text="M" />
- </buttons>
- </ButtonBar>
- <ButtonBar layoutX="15.0" layoutY="534.0" prefHeight="36.0" prefWidth="860.0">
- <buttons>
- <Button mnemonicParsing="false" text="A" />
- <Button mnemonicParsing="false" text="S" />
- <Button mnemonicParsing="false" text="D" />
- <Button mnemonicParsing="false" text="F" />
- <Button mnemonicParsing="false" text="G" />
- <Button mnemonicParsing="false" text="H" />
- <Button mnemonicParsing="false" text="J" />
- <Button mnemonicParsing="false" text="K" />
- </buttons>
- </ButtonBar>
- <ButtonBar layoutX="22.0" layoutY="491.0" prefHeight="25.0" prefWidth="583.0">
- <buttons>
- <Button minWidth="13.0" mnemonicParsing="false" prefHeight="25.0" text="Q" />
- <Button mnemonicParsing="false" text="W" />
- <Button mnemonicParsing="false" text="E" />
- <Button mnemonicParsing="false" text="R" />
- <Button mnemonicParsing="false" text="T" />
- <Button mnemonicParsing="false" text="Z" />
- <Button mnemonicParsing="false" text="U" />
- <Button mnemonicParsing="false" text="I" />
- <Button mnemonicParsing="false" text="O" />
- <Button mnemonicParsing="false" text="Löschen" />
- </buttons>
- </ButtonBar>
- <ButtonBar layoutX="39.0" layoutY="418.0" prefHeight="36.0" prefWidth="860.0">
- <buttons>
- <Button mnemonicParsing="false" text="L" />
- <Button mnemonicParsing="false" text="P" />
- <Button mnemonicParsing="false" text="Y" />
- <Button mnemonicParsing="false" text="X" />
- <Button mnemonicParsing="false" text="C" />
- <Button mnemonicParsing="false" text="V" />
- <Button mnemonicParsing="false" text="B" />
- <Button mnemonicParsing="false" text="N" />
- <Button mnemonicParsing="false" text="M" />
- </buttons>
- </ButtonBar>
- <ButtonBar layoutX="23.0" layoutY="382.0" prefHeight="36.0" prefWidth="860.0">
- <buttons>
- <Button mnemonicParsing="false" text="A" />
- <Button mnemonicParsing="false" text="S" />
- <Button mnemonicParsing="false" text="D" />
- <Button mnemonicParsing="false" text="F" />
- <Button mnemonicParsing="false" text="G" />
- <Button mnemonicParsing="false" text="H" />
- <Button mnemonicParsing="false" text="J" />
- <Button mnemonicParsing="false" text="K" />
- </buttons>
- </ButtonBar>
- <ButtonBar layoutX="30.0" layoutY="339.0" prefHeight="25.0" prefWidth="583.0">
- <buttons>
- <Button minWidth="13.0" mnemonicParsing="false" prefHeight="25.0" text="Q" />
- <Button mnemonicParsing="false" text="W" />
- <Button mnemonicParsing="false" text="E" />
- <Button mnemonicParsing="false" text="R" />
- <Button mnemonicParsing="false" text="T" />
- <Button mnemonicParsing="false" text="Z" />
- <Button mnemonicParsing="false" text="U" />
- <Button mnemonicParsing="false" text="I" />
- <Button mnemonicParsing="false" text="O" />
- </buttons>
- </ButtonBar>
- <MenuButton fx:id="w1" layoutX="91.0" layoutY="76.0" mnemonicParsing="false" text="I">
-<!-- <items>-->
-<!-- <MenuItem fx:id="w1I" mnemonicParsing="false" onAction="#w1I" text="I" />-->
-<!-- <MenuItem fx:id="w1II" mnemonicParsing="false" onAction="#w1II" text="II" />-->
-<!-- <MenuItem fx:id="w1III" mnemonicParsing="false" onAction="#w1III" text="III" />-->
-<!-- <MenuItem fx:id="w1IV" mnemonicParsing="false" onAction="#w1IV" text="IV" />-->
-<!-- <MenuItem fx:id="w1V" mnemonicParsing="false" onAction="#w1V" text="V" />-->
-<!-- </items>-->
- </MenuButton>
- <MenuButton fx:id="w3" layoutX="171.0" layoutY="76.0" mnemonicParsing="false" text="I">
- <items>
- <MenuItem fx:id="w3I" mnemonicParsing="false" onAction="#w3I" text="I" />
- <MenuItem fx:id="w3II" mnemonicParsing="false" onAction="#w3II" text="II" />
- <MenuItem fx:id="w3III" mnemonicParsing="false" onAction="#w3III" text="III" />
- <MenuItem fx:id="w3IV" mnemonicParsing="false" onAction="#w3IV" text="IV" />
- <MenuItem fx:id="w3V" mnemonicParsing="false" onAction="#w3V" text="V" />
- </items>
- </MenuButton>
- <MenuButton fx:id="w2" layoutX="133.0" layoutY="76.0" mnemonicParsing="false" text="I">
- <items>
- <MenuItem fx:id="w2I" mnemonicParsing="false" onAction="#w2I" text="I" />
- <MenuItem fx:id="w2II" mnemonicParsing="false" onAction="#w2II" text="II" />
- <MenuItem fx:id="w2III" mnemonicParsing="false" onAction="#w2III" text="III" />
- <MenuItem fx:id="w2IV" mnemonicParsing="false" onAction="#w2IV" text="IV" />
- <MenuItem fx:id="w2V" mnemonicParsing="false" onAction="#w2V" text="V" />
- </items>
- </MenuButton>
-<!-- <MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">-->
-<!-- <items>-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z1" text="1" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z2" text="2" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z3" text="3" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z4" text="4" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z5" text="5" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z6" text="6" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z7" text="7" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z8" text="8" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z9" text="9" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z10" text="10" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z11" text="11" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z12" text="12" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z13" text="13" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z14" text="14" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z15" text="15" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z16" text="16" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z17" text="17" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z18" text="18" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z19" text="19" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z20" text="20" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z21" text="21" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z22" text="22" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z23" text="23" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z24" text="24" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z25" text="25" />-->
-<!-- <MenuItem mnemonicParsing="false" onAction="#z26" text="26" />-->
-<!-- </items>-->
-<!-- </MenuButton>-->
- <MenuButton layoutX="173.0" layoutY="114.0" mnemonicParsing="false">
- <items>
- <MenuItem mnemonicParsing="false" text="Action 1" />
- <MenuItem mnemonicParsing="false" text="Action 2" />
- </items>
- </MenuButton>
- <MenuButton layoutX="135.0" layoutY="114.0" mnemonicParsing="false">
- <items>
- <MenuItem mnemonicParsing="false" text="Action 1" />
- <MenuItem mnemonicParsing="false" text="Action 2" />
- </items>
- </MenuButton>
- <MenuButton layoutX="95.0" layoutY="157.0" mnemonicParsing="false">
- <items>
- <MenuItem mnemonicParsing="false" text="Action 1" />
- <MenuItem mnemonicParsing="false" text="Action 2" />
- </items>
- </MenuButton>
- <MenuButton layoutX="175.0" layoutY="157.0" mnemonicParsing="false">
- <items>
- <MenuItem mnemonicParsing="false" text="Action 1" />
- <MenuItem mnemonicParsing="false" text="Action 2" />
- </items>
- </MenuButton>
- <MenuButton layoutX="137.0" layoutY="157.0" mnemonicParsing="false">
- <items>
- <MenuItem mnemonicParsing="false" text="Action 1" />
- <MenuItem mnemonicParsing="false" text="Action 2" />
- </items>
- </MenuButton>
- <TextField layoutX="246.0" layoutY="76.0" prefHeight="77.0" prefWidth="410.0" />
- <TextField layoutX="248.0" layoutY="182.0" prefHeight="77.0" prefWidth="410.0" />
- <Button layoutX="717.0" layoutY="221.0" mnemonicParsing="false" onAction="#btnsenden" prefHeight="69.0" prefWidth="164.0" text="An Funker senden" />
- <Button layoutX="717.0" layoutY="135.0" mnemonicParsing="false" prefHeight="69.0" prefWidth="164.0" text="Funkspruch empfangen" />
- <TextField layoutX="725.0" layoutY="76.0" />
- <Label layoutX="727.0" layoutY="51.0" prefHeight="17.0" prefWidth="149.0" text="Kenngruppe" />
- <MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">
- <items>
- <MenuItem mnemonicParsing="false" text="Action 1" />
- <MenuItem mnemonicParsing="false" text="Action 2" />
- </items>
- </MenuButton>
- </children>
-</AnchorPane>
diff --git a/src/main/resources/Enigma/secondary.fxml b/src/main/resources/Enigma/secondary.fxml
deleted file mode 100644
index 6f0d942833692b3137fbe7119541faecce085034..0000000000000000000000000000000000000000
--- a/src/main/resources/Enigma/secondary.fxml
+++ /dev/null
@@ -1,16 +0,0 @@
-<?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>
diff --git a/src/main/resources/Enigma/codebuch.sqlite b/src/main/resources/projekt/enigma/codebuch.sqlite
similarity index 92%
rename from src/main/resources/Enigma/codebuch.sqlite
rename to src/main/resources/projekt/enigma/codebuch.sqlite
index 78be5227db85283c0c20e3719303cb77e48e8cbf..018731d4221da62ff7e8702ce5f52833bccbea05 100644
Binary files a/src/main/resources/Enigma/codebuch.sqlite and b/src/main/resources/projekt/enigma/codebuch.sqlite differ
diff --git a/src/main/resources/projekt/enigma/gui.fxml b/src/main/resources/projekt/enigma/gui.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..8630069413fb732ad0ed6f81fbe7b28ce2efa52f
--- /dev/null
+++ b/src/main/resources/projekt/enigma/gui.fxml
@@ -0,0 +1,629 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.MenuButton?>
+<?import javafx.scene.control.ProgressBar?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.ColumnConstraints?>
+<?import javafx.scene.layout.FlowPane?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.RowConstraints?>
+<?import javafx.scene.layout.TilePane?>
+<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.shape.Circle?>
+<?import javafx.scene.text.Font?>
+
+<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="677.0" prefWidth="967.0" xmlns="http://javafx.com/javafx/8.0.999-ea" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.GuiController">
+ <children>
+ <GridPane layoutY="313.0" prefHeight="393.0" prefWidth="968.0" AnchorPane.bottomAnchor="-7.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="313.0">
+ <columnConstraints>
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+ </columnConstraints>
+ <rowConstraints>
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints maxHeight="63.0" minHeight="10.0" prefHeight="63.0" vgrow="SOMETIMES" />
+ <RowConstraints maxHeight="41.0" minHeight="10.0" prefHeight="29.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ </rowConstraints>
+ <children>
+ <TextField fx:id="tfStecker1" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="1" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker2" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="2" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker3" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="3" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker4" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="4" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker5" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="5" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker6" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="6" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker7" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="7" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker8" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="8" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker9" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="9" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <TextField fx:id="tfStecker10" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="10" GridPane.rowIndex="7">
+ <GridPane.margin>
+ <Insets left="10.0" right="10.0" />
+ </GridPane.margin>
+ </TextField>
+ <Button fx:id="btnM" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="M" textFill="#fffdfd" GridPane.columnIndex="9" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnN" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="N" textFill="#fffdfd" GridPane.columnIndex="8" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnB" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="B" textFill="#fffdfd" GridPane.columnIndex="7" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnV" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="V" textFill="#fffdfd" GridPane.columnIndex="6" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnC" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="C" textFill="#fffdfd" GridPane.columnIndex="5" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnX" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="X" textFill="#fffdfd" GridPane.columnIndex="4" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnY" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="Y" textFill="#fffdfd" GridPane.columnIndex="3" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnP" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="P" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnL" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="L" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="6">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnK" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="K" textFill="#fffdfd" GridPane.columnIndex="9" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Button fx:id="btnJ" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="J" textFill="#fffdfd" GridPane.columnIndex="8" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Button fx:id="btnH" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="H" textFill="#fffdfd" GridPane.columnIndex="7" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Button fx:id="btnG" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="G" textFill="#fffdfd" GridPane.columnIndex="6" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Button fx:id="btnF" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="F" textFill="#fffdfd" GridPane.columnIndex="5" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Button fx:id="btnD" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="D" textFill="#fffdfd" GridPane.columnIndex="4" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Button fx:id="btnS" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="S" textFill="#fffdfd" GridPane.columnIndex="3" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Button fx:id="btnO" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="O" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnI" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="I" textFill="#fffdfd" GridPane.columnIndex="9" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnU" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="U" textFill="#fffdfd" GridPane.columnIndex="8" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnZ" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="Z" textFill="#fffdfd" GridPane.columnIndex="7" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnT" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="T" textFill="#fffdfd" GridPane.columnIndex="6" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnR" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="R" textFill="#fffdfd" GridPane.columnIndex="5" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnE" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="E" textFill="#fffdfd" GridPane.columnIndex="4" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnW" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="W" textFill="#fffdfd" GridPane.columnIndex="3" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnQ" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="Q" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="4">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ <Button fx:id="btnDelete" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="<" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="5">
+ <font>
+ <Font size="18.0" />
+ </font>
+ <GridPane.margin>
+ <Insets left="28.0" />
+ </GridPane.margin>
+ </Button>
+ <Circle fx:id="circL" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="10" GridPane.rowIndex="2" />
+ <Circle fx:id="circM" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="9" GridPane.rowIndex="2" />
+ <Circle fx:id="circN" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="8" GridPane.rowIndex="2" />
+ <Circle fx:id="circB" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="7" GridPane.rowIndex="2" />
+ <Circle fx:id="circV" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="6" GridPane.rowIndex="2" />
+ <Circle fx:id="circC" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="5" GridPane.rowIndex="2" />
+ <Circle fx:id="circX" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="4" GridPane.rowIndex="2" />
+ <Circle fx:id="circY" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="3" GridPane.rowIndex="2" />
+ <Circle fx:id="circP" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="2" GridPane.rowIndex="2" />
+ <Circle fx:id="circK" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="9" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets left="35.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circJ" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="8" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets left="35.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circH" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="7" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circG" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="6" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets left="35.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circF" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="5" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets left="35.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circD" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="4" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets left="35.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circS" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="3" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets left="35.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circA" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="2" GridPane.rowIndex="1">
+ <GridPane.margin>
+ <Insets left="35.0" />
+ </GridPane.margin>
+ </Circle>
+ <Circle fx:id="circO" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="10" />
+ <Circle fx:id="circI" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="9" />
+ <Circle fx:id="circU" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="8" />
+ <Circle fx:id="circZ" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="7" />
+ <Circle fx:id="circT" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="6" />
+ <Circle fx:id="circR" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="5" />
+ <Circle fx:id="circE" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="4" />
+ <Circle fx:id="circW" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="3" />
+ <Circle fx:id="circQ" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="2" />
+ <Label fx:id="lblL" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="L" GridPane.columnIndex="10" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblM" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="M" GridPane.columnIndex="9" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblN" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="N" GridPane.columnIndex="8" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblB" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="B" GridPane.columnIndex="7" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblV" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="V" GridPane.columnIndex="6" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblC" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="C" GridPane.columnIndex="5" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblX" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="X" GridPane.columnIndex="4" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblY" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="Y" GridPane.columnIndex="3" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblP" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="P" GridPane.columnIndex="2" GridPane.rowIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblK" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="K" GridPane.columnIndex="9" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblJ" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="J" GridPane.columnIndex="8" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblH" alignment="CENTER" minHeight="0.0" prefHeight="27.0" prefWidth="25.0" text="H" GridPane.columnIndex="7" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="6.0" left="50.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblG" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="G" GridPane.columnIndex="6" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblF" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="F" GridPane.columnIndex="5" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblD" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="D" GridPane.columnIndex="4" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblS" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="S" GridPane.columnIndex="3" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblA" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="A" GridPane.columnIndex="2" GridPane.rowIndex="1">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="4.0" left="42.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblQ" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="Q" GridPane.columnIndex="2">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblW" alignment="CENTER" prefHeight="36.0" prefWidth="30.0" text="W" GridPane.columnIndex="3">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="1.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblE" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="E" textAlignment="CENTER" GridPane.columnIndex="4">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblR" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="R" textAlignment="CENTER" GridPane.columnIndex="5">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblT" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="T" textAlignment="CENTER" GridPane.columnIndex="6">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblZ" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="Z" textAlignment="CENTER" GridPane.columnIndex="7">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblU" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="U" textAlignment="CENTER" GridPane.columnIndex="8">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblI" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="I" textAlignment="CENTER" GridPane.columnIndex="9">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <Label fx:id="lblO" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="O" textAlignment="CENTER" GridPane.columnIndex="10">
+ <font>
+ <Font size="23.0" />
+ </font>
+ <GridPane.margin>
+ <Insets bottom="2.0" left="7.0" />
+ </GridPane.margin>
+ </Label>
+ <TilePane prefHeight="200.0" prefWidth="200.0" GridPane.columnIndex="1" GridPane.rowIndex="4" />
+ <VBox prefHeight="200.0" prefWidth="152.0" GridPane.columnIndex="11" />
+ <Button fx:id="btnA" minHeight="35.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="35.0" prefWidth="42.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="A" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="5">
+ <font>
+ <Font name="System Bold" size="18.0" />
+ </font>
+ </Button>
+ </children>
+ </GridPane>
+ <AnchorPane layoutX="241.0" layoutY="130.0" prefHeight="111.0" prefWidth="487.0" AnchorPane.leftAnchor="241.0" AnchorPane.rightAnchor="240.0">
+ <children>
+ <VBox layoutX="72.0" layoutY="-89.0" prefHeight="210.0" prefWidth="377.0" AnchorPane.bottomAnchor="-10.0" AnchorPane.leftAnchor="72.0" AnchorPane.rightAnchor="37.0" AnchorPane.topAnchor="-89.0">
+ <children>
+ <TextField fx:id="tfKlartext" editable="false" prefHeight="80.0" prefWidth="377.0" />
+ <Label prefHeight="17.0" prefWidth="385.0" />
+ <TextField fx:id="tfCodiert" editable="false" prefHeight="79.0" prefWidth="377.0" />
+ <Label prefHeight="17.0" prefWidth="385.0" />
+ <Label fx:id="lblLadeNachricht" alignment="BASELINE_CENTER" contentDisplay="CENTER" prefHeight="5.0" prefWidth="377.0" text="Neue Nachricht wird vom Funkraum abgerufen!" />
+ <ProgressBar fx:id="pbLadeNachricht" prefHeight="10.0" prefWidth="377.0" progress="0.0" />
+ </children>
+ </VBox>
+ </children></AnchorPane>
+ <GridPane layoutX="23.0" layoutY="60.0" prefHeight="158.0" prefWidth="237.0" AnchorPane.leftAnchor="23.0" AnchorPane.topAnchor="60.0">
+ <columnConstraints>
+ <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+ </columnConstraints>
+ <rowConstraints>
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ </rowConstraints>
+ <children>
+ <Label text="Walze" />
+ <Label text="Ringe" GridPane.rowIndex="1" />
+ <Label text="Position" GridPane.rowIndex="2" />
+ <MenuButton fx:id="mBtnWalzPos1" alignment="CENTER_RIGHT" contentDisplay="CENTER" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="I" GridPane.columnIndex="1">
+ </MenuButton>
+ <MenuButton fx:id="mBtnWalzPos2" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="I" textAlignment="CENTER" GridPane.columnIndex="2">
+ </MenuButton>
+ <MenuButton fx:id="mBtnWalzPos3" mnemonicParsing="false" popupSide="TOP" prefHeight="25.0" prefWidth="48.0" text="I" textAlignment="CENTER" GridPane.columnIndex="3">
+ </MenuButton>
+ <MenuButton fx:id="mBtnNotchPos1" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="1" textAlignment="CENTER" GridPane.columnIndex="1" GridPane.rowIndex="1" />
+ <MenuButton fx:id="mBtnNotchPos2" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="1" textAlignment="CENTER" GridPane.columnIndex="2" GridPane.rowIndex="1">
+ </MenuButton>
+ <!-- <MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">-->
+ <!-- <items>-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z1" text="1" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z2" text="2" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z3" text="3" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z4" text="4" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z5" text="5" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z6" text="6" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z7" text="7" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z8" text="8" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z9" text="9" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z10" text="10" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z11" text="11" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z12" text="12" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z13" text="13" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z14" text="14" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z15" text="15" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z16" text="16" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z17" text="17" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z18" text="18" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z19" text="19" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z20" text="20" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z21" text="21" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z22" text="22" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z23" text="23" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z24" text="24" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z25" text="25" />-->
+ <!-- <MenuItem mnemonicParsing="false" onAction="#z26" text="26" />-->
+ <!-- </items>-->
+ <!-- </MenuButton>-->
+ <MenuButton fx:id="mBtnNotchPos3" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="1" textAlignment="CENTER" GridPane.columnIndex="3" GridPane.rowIndex="1">
+ </MenuButton>
+ <MenuButton fx:id="mBtnStartPos1" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="A" textAlignment="CENTER" GridPane.columnIndex="1" GridPane.rowIndex="2">
+ </MenuButton>
+ <MenuButton fx:id="mBtnStartPos2" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="A" textAlignment="CENTER" GridPane.columnIndex="2" GridPane.rowIndex="2">
+ </MenuButton>
+ <MenuButton fx:id="mBtnStartPos3" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="A" textAlignment="CENTER" GridPane.columnIndex="3" GridPane.rowIndex="2">
+ </MenuButton>
+ </children>
+ </GridPane>
+ <FlowPane layoutX="736.0" layoutY="51.0" prefHeight="173.0" prefWidth="195.0" AnchorPane.rightAnchor="36.0" AnchorPane.topAnchor="51.0">
+ <children>
+ <Button fx:id="btnEmpfangen" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="80.0" prefWidth="195.0" text="Funkspruch empfangen" />
+ <Label prefHeight="17.0" prefWidth="195.0" />
+ <Button fx:id="btnSenden" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="80.0" prefWidth="195.0" text="An Funker senden" />
+ </children>
+ </FlowPane>
+ <GridPane layoutX="23.0" layoutY="222.0" prefHeight="60.0" prefWidth="270.0" AnchorPane.leftAnchor="23.0" AnchorPane.topAnchor="222.0">
+ <columnConstraints>
+ <ColumnConstraints hgrow="SOMETIMES" maxWidth="130.0" minWidth="10.0" prefWidth="100.0" />
+ <ColumnConstraints hgrow="SOMETIMES" maxWidth="224.0" minWidth="10.0" prefWidth="170.0" />
+ </columnConstraints>
+ <rowConstraints>
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+ </rowConstraints>
+ <children>
+ <Label alignment="CENTER_RIGHT" text="Tagesschlüssel:" />
+ <Label text="Spruchschlüssel:" GridPane.rowIndex="1" />
+ <Label fx:id="lblTagesschluessel" prefHeight="17.0" prefWidth="181.0" GridPane.columnIndex="1" />
+ <Label fx:id="lblSpruchschluessel" prefHeight="17.0" prefWidth="181.0" GridPane.columnIndex="1" GridPane.rowIndex="1" />
+ </children>
+ </GridPane>
+ </children>
+</AnchorPane>
diff --git a/src/main/resources/projekt/enigma/kenngruppe.fxml b/src/main/resources/projekt/enigma/kenngruppe.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..2cedf3644a5b65ea0c8f53751137ac55e051acd3
--- /dev/null
+++ b/src/main/resources/projekt/enigma/kenngruppe.fxml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.shape.Circle?>
+
+<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="411.0" prefWidth="512.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.KenngruppeController">
+ <children>
+ <Label layoutX="81.0" layoutY="29.0" text="Bitte Kenngruppe eingeben!" AnchorPane.leftAnchor="81.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="29.0" />
+ <HBox layoutX="107.0" layoutY="141.0" prefHeight="26.0" prefWidth="276.0" AnchorPane.leftAnchor="107.0" AnchorPane.rightAnchor="129.0" AnchorPane.topAnchor="141.0">
+ <children>
+ <Button fx:id="secondaryButton" onAction="#switchToPrimary" prefHeight="25.0" prefWidth="142.0" text="Kenngruppe bestätigen!" />
+ <Label prefHeight="17.0" prefWidth="159.0" text="Label" />
+ <Button mnemonicParsing="false" prefHeight="25.0" prefWidth="150.0" text="Button" />
+ </children>
+ </HBox>
+ <Circle fill="DODGERBLUE" layoutX="226.0" layoutY="267.0" radius="100.0" stroke="BLACK" strokeType="INSIDE" AnchorPane.leftAnchor="126.0" AnchorPane.rightAnchor="186.0" AnchorPane.topAnchor="167.0" />
+ <Button fx:id="secondaryButton" layoutX="40.0" layoutY="85.0" onAction="#switchToPrimary" prefHeight="25.0" prefWidth="241.0" text="Kenngruppe bestätigen!" />
+ </children>
+</AnchorPane>
diff --git a/src/test/java/Enigma/model/CodebuchTest.java b/src/test/java/Enigma/model/CodebuchTest.java
deleted file mode 100644
index 91e265342537fdf07e92ca735f9e377b48b4e424..0000000000000000000000000000000000000000
--- a/src/test/java/Enigma/model/CodebuchTest.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package Enigma.model;
-
-import org.junit.Assert;
-import org.junit.Test;
-import java.sql.SQLException;
-
-public class CodebuchTest {
-
- @Test
- public void testToString() {
- String expected = "Tag: 1\n" +
- "Walzenlage: 1,3,2\n" +
- "Ringstellung: 16,11,13\n" +
- "Steckverbindung: CO,DI,FR,HU,JW,LS,TX\n";
-
- try {
- // Codebuch abrufen
- Codebuch cb = new DatenbankSqlite().getCodebuch(1);
- // Ausgabe auf der Konsole
- String result = new DatenbankSqlite().getCodebuch(1).toString();
- Assert.assertEquals(expected, result);
- } catch (SQLException e) {
- e.printStackTrace();
- }
- }
-
- @Test
- public void getTag() {
- Codebuch cb = new Codebuch();
- cb.setTag(1);
- Assert.assertEquals(1, cb.getTag());
- }
-}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/SteckbrettTest.java b/src/test/java/Enigma/model/SteckbrettTest.java
deleted file mode 100644
index df6051df00bcd397568a5e9e88ba5295eba803a0..0000000000000000000000000000000000000000
--- a/src/test/java/Enigma/model/SteckbrettTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package Enigma.model;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-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'));*/
- }
-
- @Test
- public void codiere2() {
- /*Steckbrett sb = new Steckbrett();
- sb.setzeVertauschung('A', 'G');
- sb.setzeVertauschung('C', 'H');
- Assert.assertEquals('C', sb.codiere2('H'));
- Assert.assertEquals('A', sb.codiere2('G'));*/
- }
-}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/WalzeTest.java b/src/test/java/Enigma/model/WalzeTest.java
deleted file mode 100644
index 1c58136c318dbbdce13c250cbadba805805aa0ad..0000000000000000000000000000000000000000
--- a/src/test/java/Enigma/model/WalzeTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package Enigma.model;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class WalzeTest {
-
- @Test
- public void setzeNotch() {
- /*Walze w = new Walze(1);
- w.setzeNotch('G');
- Assert.assertEquals('G', w.wlazenPosition());*/
- }
-
- @Test
- public void dreheWalze() {
- /*Walze w = new Walze(1);
- w.setzeNotch('G');
- w.dreheWalze();
- Assert.assertEquals('H', w.wlazenPosition());*/
- }
-
- @Test
- public void walzenPoition() {
- /*Walze w = new Walze(1);
- w.setzeNotch('G');
- Assert.assertEquals('G', w.wlazenPosition());*/
- }
-
- @Test
- public void codiere() {
- /*Walze w = new Walze(1);
- w.setzeNotch('A');
- Assert.assertEquals('E', w.codiere('A'));*/
- }
-
- @Test
- public void codiere2() {
- /*Walze w = new Walze(1);
- w.setzeNotch('A');
- Assert.assertEquals('A', w.codiere('E'));*/
- }
-}
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/CodebuchTest.java b/src/test/java/projekt/enigma/model/CodebuchTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce7da24a9153fcda79ae1811ac3759e58327a21a
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/CodebuchTest.java
@@ -0,0 +1,28 @@
+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
diff --git a/src/test/java/projekt/enigma/model/HardwareTest.java b/src/test/java/projekt/enigma/model/HardwareTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c1fc82e3ffb96e35caf063154630e06a8a434b8
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/HardwareTest.java
@@ -0,0 +1,64 @@
+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());
+ h.setWalzen(0, 1, 1);
+ h.setWalzen(1, 2, 1);
+ h.setWalzen(2, 3, 1);
+
+ /*
+ 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 {'B', 'G', 'D', 'F'}
+ Steckbrett {'G', 'B', 'F', 'F'}
+ Walze 3 {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+ Walze 2 {'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'};
+ Walze 1 {'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'};
+ 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.resetWalzen();
+ result = h.codiere('A');
+ Assert.assertEquals("Codiere: A Erwartet G, erhalten " + result, 'G', result);
+ result = h.codiere('B');
+ Assert.assertEquals("Codiere: B Erwartet H, erhalten " + result, 'H', result);
+ result = h.codiere('I');
+ Assert.assertEquals("Codiere: I Erwartet C, erhalten " + result, 'C', result);
+ result = h.codiere('F');
+ Assert.assertEquals("Codiere: F Erwartet U, erhalten " + result, 'U', result);
+
+ h.resetWalzen();
+ result = h.codiere('G');
+ Assert.assertEquals("Decodiere: G Erwartet A, erhalten " + result, 'A', result);
+ result = h.codiere('H');
+ Assert.assertEquals("Decodiere: R Erwartet H, erhalten " + result, 'B', result);
+ result = h.codiere('C');
+ Assert.assertEquals("Decodiere: C Erwartet I, erhalten " + result, 'I', result);
+ result = h.codiere('U');
+ Assert.assertEquals("Decodiere: U Erwartet F, erhalten " + result, 'F', result);
+
+ h.resetWalzen();
+ h.getSteckbrett().setzeVertauschung('B', 'G');
+ h.getSteckbrett().setzeVertauschung('D', 'F');
+ h.getSteckbrett().setzeVertauschung('I', 'L');
+ h.getSteckbrett().setzeVertauschung('M', 'Q');
+ h.getSteckbrett().setzeVertauschung('T', 'X');
+
+ result = h.codiere('I');
+ Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'F', result);
+
+ h.resetWalzen();
+ result = h.codiere('K');
+ Assert.assertEquals("Codiere: K Erwartet D, erhalten " + result, 'D', result);
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/ReflektorTest.java b/src/test/java/projekt/enigma/model/ReflektorTest.java
similarity index 78%
rename from src/test/java/Enigma/model/ReflektorTest.java
rename to src/test/java/projekt/enigma/model/ReflektorTest.java
index 74ab4f6410b5aa1592c9ed50903372ef774c70f5..8cb11a94b3c94191e9d0cdec15ddfbf97f5d27ea 100644
--- a/src/test/java/Enigma/model/ReflektorTest.java
+++ b/src/test/java/projekt/enigma/model/ReflektorTest.java
@@ -1,4 +1,4 @@
-package Enigma.model;
+package projekt.enigma.model;
import org.junit.Assert;
import org.junit.Test;
@@ -7,7 +7,6 @@ public class ReflektorTest {
@Test
public void codiere() {
- /*
Reflektor r = new Reflektor();
Assert.assertEquals('E', r.codiere('A'));
@@ -15,19 +14,10 @@ public class ReflektorTest {
Assert.assertEquals('X', r.codiere('H'));
Assert.assertEquals('O', r.codiere('Q'));
Assert.assertEquals('I', r.codiere('V'));
- //Assert.assertNull(null, r.codiere(null));
- */
- }
-
- @Test
- public void codiere2() {
- /*
- Reflektor r = new Reflektor();
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
diff --git a/src/test/java/projekt/enigma/model/SteckbrettTest.java b/src/test/java/projekt/enigma/model/SteckbrettTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..689b923f05fa2261a0b75ce33b9905221eb3fac6
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/SteckbrettTest.java
@@ -0,0 +1,25 @@
+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
diff --git a/src/test/java/projekt/enigma/model/WalzeTest.java b/src/test/java/projekt/enigma/model/WalzeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a53f3832b36f9bffa8fba90d0c7919be12ddb09d
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/WalzeTest.java
@@ -0,0 +1,45 @@
+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, 3);
+ 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