diff --git a/src/main/java/Enigma/GuiController.java b/src/main/java/Enigma/GuiController.java
index 67af4eb889ae48d59e2146e7b1638c0b30ecceb8..e3136573da00b273dc44500256c79cf82a391123 100644
--- a/src/main/java/Enigma/GuiController.java
+++ b/src/main/java/Enigma/GuiController.java
@@ -8,7 +8,7 @@ import javafx.scene.control.MenuItem;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
-public class GuiController2 {
+public class GuiController {
private ArrayList<MenuItem> mItem;
private final static String[] str= {"I", "II", "III", "IV", "V"};
private final static String[] num ={"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"};
diff --git a/src/main/java/Enigma/model/walze01/SchaltungWalzeNo_1.java b/src/main/java/Enigma/model/walze01/SchaltungWalzeNo_1.java
new file mode 100644
index 0000000000000000000000000000000000000000..616729fe82526871b4ac62e31d5e1751090644a7
--- /dev/null
+++ b/src/main/java/Enigma/model/walze01/SchaltungWalzeNo_1.java
@@ -0,0 +1,20 @@
+package Enigma.model.walze01;
+
+public enum SchaltungWalzeNo_1 {
+
+ A('E') {
+ public int getPos() {
+
+ return foo;
+ }
+ },
+ 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 {};
+
+
+ SchaltungWalzeNo_1(char chiffre) {
+ }
+}
+
+
+
+
diff --git a/src/main/java/Enigma/model/walze01/WalzeUli.java b/src/main/java/Enigma/model/walze01/WalzeUli.java
new file mode 100644
index 0000000000000000000000000000000000000000..7964d67283687e329f891308e94940001fc6ef94
--- /dev/null
+++ b/src/main/java/Enigma/model/walze01/WalzeUli.java
@@ -0,0 +1,226 @@
+package Enigma.model.walze01;
+
+public class WalzeUli {
+
+/*
+ private Character buchstabe;
+ private Character ringstellung;
+ private int walzennr;
+ private int iPositionBuchstabe;
+ private int iPositionBuchstabeRe;
+ private Character[] walze;
+*/
+
+public WalzeUli(){}
+ enum SchaltungWalzeNo_I {
+
+
+
+ /**
+ * 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 WalzeUli(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;
+ }
+
+}