/*

--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
---------------------------------- Ein einfacher Taschenrechner ----------------------------------
--------------------------------------------------------------------------------------------------
------------------------------------ Fachreferrat Technologie ------------------------------------
------------------------------------------ 8. Mai 2003 -------------------------------------------
------------------------------------- Thomas Kagerer, B12Ta --------------------------------------
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------

*/
	
	//Die verschiedenen Klassen, die benötigt werden, werden implementiert.
	//java.math.* wird z.B. für mathematische Berechnungen benötigt.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.io.*;
import java.math.*;
import java.text.*;

	//Die Klasse (Das Programm) Techno als Applet, das die Listener (Horcher),
	//MouseListener (Tastendrücke, etc), MouseMotionListener (Mausbewegungen)
	//und den ActionListener (Druck auf Buttons) implementiert.
public class Techno extends Applet implements MouseListener, MouseMotionListener, ActionListener{


	/* ------------------ Globale Variablen setzen: ------------------ */

	//Höhe und Breite des kompletten Applets
int Breite;
int Hoehe;

	//Linke Obere Ecke des Rechners
int X = 0;
int Y = 0;

	//Linke Obere Ecke des 'imaginären' Rechners, der auch ausserhalb Werte ausserhalb der
	//sichtbaren Appletgrenzen annehmen kann und so sicherstellt, dass man den realen
	//Rechner immer an derselben Stelle an der Titelleiste anfasst
int Xi = 0;
int Yi = 0;

	//Höhe und Breite des Taschenrechners.
int W = 212;
int H = 259;

	//Höhe der Titelleiste des Rechners
int TH = 27;

	//Anfangswerte für die Position des Mauszeigers beim verschieben des Rechners.
int DX = 0;
int DY = 0;

	//Wert, der dem Applet sagt, ob beim drücken der Maustaste der Zeiger über der Titelleiste war.
boolean drag = false;

	//Wert, der dem Applet sagt, ob der Rechner schon verschoben wurde oder gerade das erste Mal
	//verschoben wird.
boolean dragfirst = false;

	//on = true bedeutet, der Rechner ist eingeschaltet. E.G.: on = false bedeutet der Rechner ist aus.
boolean on = false;

	//Wenn Rand = true, dann wird um den Rechner ein schwarzer Markierungsrahmen gemalt
	//(Beim Verschieben)
boolean Rand = false;

	//o_p (operator_pressed), sagt aus, ob das letzte gedrückte Zeichen ein Operator (+,-,*,/) war
boolean o_p = false;

	//p_p (point_pressed), sagt aus, ob das letzte gedrckte Zeichen ein Punkt (.) war
boolean p_p = false;

	//z_p (zahl_pressed), sagt aus, ob das letzte gedrückte Zeichen eine Zahl ([0;9]) war
boolean z_p = false;

	//p_id (punkt_im_display), sagt aus, ob ein Punkt schon getippt wurde
boolean p_id = false;

	//pi_id (pi_im_display), sagt aus, ob im Display schon pi steht
boolean pi_id = false;

	//laeuft sagt dem Applet ob eine Rechnung gerade läuft.
	//Wenn ja dann wird beim drücken auf einen Operator eine Rechnung durchgeführt, andererseits nicht
boolean laeuft = false;

	//Wenn eine Division durch 0 durchgeführt wurde, ist dieser Wert auf true
boolean error = false;

	//opstr (operator_string): Der zuletzt gedrückte Operator (+,-,*,/). 
	//Standardmäßig = +, da wenn opstr nicht verändert wurde, wurde auch wert1 nicht verändert und = 0.0.
	//ein Wert + 0 ist immer gleich dem Wert.
String opstr = "+";

	//Das aktuelle Ergebnis der Rechnung wird in dieser Zeichenkette abgespeichert
String wert;

	//Wenn während der Rechnung eine Zwischenrechnung durchgeführt wird, wird das Ergebnis in
	//diesem double-Wert gespeichert
double wert1 = 0.0;

	//In dieser Variable wird das letzte Ergebnis als double-Wert gespeichert, und beim
	//drücken auf 'ANS' ausgegeben
double store = 0.0;

	//Die Farbe des Rechners
Color winblue;

	//Das Bild, das die Titelleiste darstellt
Image img;

	//Das Textfeld, das die Zahlen darstellt
TextField Anz;

	//Das Panel (Container), das die Knöpfe (Buttons) und das Textfeld (TextField) enthält
Panel P;

	//Die init() - Funktion wird beim Starten des Applets aufgerufen
  public void init() {
  	//Der MouseListener und der MouseMotionListener werden auf this 
	//(Das Object, das gerade ausgewählt ist = Das komplette Applet) angewendet
	//was bedeutet dass die zuegörigen Funktionen je nach event aufgerufen werden
    addMouseListener(this);
    addMouseMotionListener(this);
    	//Der Hintergrund für das Applet wird auf weiß gesetzt
    setBackground(Color.white);
    	//Eine neue Dimension wird erzeugt (Repräsentiert die Ebene des Applets)
	//und daraus die Größe des Applets ausgelesen und auf die globalen
	//Variablen Breite und Hoehe geschrieben
    Dimension d = getSize();
    Breite = d.width;
    Hoehe = d.height;
    	//Die Farbei winblue wird erzeugt
    winblue = new Color(75,108,191);    
    	//ein neuer LayoutManager im GridLayout-Format wird dem Panel zugewiesen
	//(6 Zeilen und 1 Spalte 5 Pixel Abstand dazwischen)
    P = new Panel(new GridLayout(6,1,5,5));
    	//Zeilenlayout: Ein neuer Layoutmanager wird im GridLayout erzeugt:
	//1 Zeile, 5 Spalten und jeweils 5 Pixel Abstand
    GridLayout Zeilenlayout = new GridLayout(1,5,5,5);
    	//6 Neue Panels werden erzeugt und denen wird das oben erzeugte Layout zugewiesen  
    Panel Z1 = new Panel(Zeilenlayout);    
    	//flow: ein neuer Layoutmanager im FlowLayout, von rechts nach links wird Z2 zugewiesen
    FlowLayout flow = new FlowLayout();
    flow.setAlignment(FlowLayout.RIGHT);
    Panel Z2 = new Panel(flow);
    Panel Z3 = new Panel(Zeilenlayout);
    Panel Z4 = new Panel(Zeilenlayout);
    Panel Z5 = new Panel(Zeilenlayout);
    Panel Z6 = new Panel(Zeilenlayout);
    	//Integervariable i repräsentiert die Menge der Tasten (Buttons)
    int i = 20;
    	//Das Array str, das die Beschriftung enthält wird mit der Länge i erzeugt
    String[] str = new String[i];
    	//Den einzelnen Arrayfeldern werden die benötigten Werte zugewiesen
    str[0] = "7";
    str[1] = "8";
    str[2] = "9";
    str[3] = "+/-";
    str[4] = "C";
    str[5] = "4";
    str[6] = "5";
    str[7] = "6";
    str[8] = "*";
    str[9] = "/";
    str[10] = "1";
    str[11] = "2";
    str[12] = "3";
    str[13] = "+";
    str[14] = "-";
    str[15] = "0";
    str[16] = ".";
    str[17] = "pi";
    str[18] = "ANS";
    str[19] = "=";
    	//Ein neues Textfeld wird erzeugt.
    Anz = new TextField(20);      		//20 Zeichen breit
    Anz.setEditable(false);       		//nicht editbar
    Anz.setText("");		  		//kein Text enthalten
    Anz.setBackground(Color.gray);		//Hintergrund: grau
    	//Das Textfeld wird zum Panel Z1 hinzugefügt
    Z1.add(Anz);
    	//Ein neuer Button mit der Aufschrift on wird erzeugt
    Button bttn = new Button("on");
    	//Dem Button wird der ActioinListener hinzugefügt, was bedeutet, dass eine Funktion
	//actionPerformed(ActionEvent e) aufgerufen wird, wenn dieser gedrückt wird
    bttn.addActionListener(this);
    bttn.setBackground(Color.white);		//weißer Hintergrund
	//Der Button wird zum Panel Z2 hinzugefügt    
    Z2.add(bttn);
    	//Eine for-Schleife, die von j = 0 bis (i-1) in 1er Schritten läuft (0,1,2,3, ... (i-1))
	//i-1 deshalb, weil in Java ein Array bei 0 startet und nicht bei 1 und somit bei 10
	//Arrayfeldern str[0] bis str[9] belegt wäre. Also muss die Schleife nur bis (i-1) laufen,
	//um alle i (20) Arrayfelder zu durchlaufen.
    for(int j=0;j<i;j++){
    	//Ein neuer Button wird erzeugt mit der jeweiligen Beschriftung aus dem weiter oben
	//erzeugtem Array str. str[0] ist also "7" und str[10] wäre "1"
    	bttn = new Button(str[j]);
	//Dem Button wird der ActionListener hinzugefügt
	bttn.addActionListener(this);
    	bttn.setBackground(Color.white);	//weißer Hintergrund
	//Bis zum 5ten Button (0,1,2,3,4) werden die Buttons zum Panel Z3, bis zum 10ten zum
	//Panel Z4, bis zum 15ten zum Panel Z5 und danach zum Panel Z6 hinzugefügt.
    	if(j<=4) Z3.add(bttn);
	else if(j<=9) Z4.add(bttn);
	else if(j<=14) Z5.add(bttn);	
	else Z6.add(bttn);	
    }
    	//Die einzelnen Panels Z1 - Z6, die zeilenweise aufgebaut sind, werden zum großen
	//Panel P hinzugefügt
    P.add(Z1);
    P.add(Z2);
    P.add(Z3);
    P.add(Z4);
    P.add(Z5);
    P.add(Z6);
    
	//Die Position P wird verändert auf 
	//X = X + 1 (X-Position = X-Position + 1 Pixel), auf
	//Y = Y + TH + 5 + 1 (Y-Position = Y-Position + Höhe der Titelleiste + 5 Pixel + 1 Pixel)
	//sowie die Größe auf Breite = W - 2 (Breite - 2 Pixel) und 
	//Höhe = Höhe - Höhe der Titelleiste - 2 Pixel - 5 Pixel
    P.setLocation(X+1,Y+TH+5+1);
    P.setSize(W-2,H-TH-2-5);
    	//Der Hintergrund von P wird auf die Farbe winblue gesetzt
    P.setBackground(winblue);
    	//P wird zum Applet hinzugefügt
    add(P);
  }
  
  	//Diese Funktion wird aufgerufen wenn auf einen Button, dem der ActionListener
	//hinzugefügt wurde, gedrückt wurde
  public void actionPerformed(ActionEvent e) {
  	//Dieser String (Zeichenkette) enthält jetzt das ActionCommand (1,2,3,...,9,+,-,/,...)
  	String str = e.getActionCommand();
	//Diese Bedingungsschleife wird ausgeführt, wenn der Wert on wahr ist
	if(on == true){
	//char beinhaltet den ASCII Code eines Zeichens. Das erste Zeichen der Zeichenkette str
	//wird in einen solchen Code umgewandelt und in die Variable Zeichen geschrieben, weil
	//die später folgende switch() Schleife nur mit Zahlen umgehen kann
		char Zeichen = str.charAt(0);
	//Wenn die Zeichenkette str gleich "+/-", dann ...
		if(str == "+/-"){
			//Aufruf der Funktion rechne() - Details bei der Funktion selbst
			rechne(str,'u'); //u für umschalten Plus/Minus
	//Wenn die Zeichenkette str nicht gleich "+/-", sondern gleich "on", dann ...
		}else if(str == "on"){
			Anz.setText("");	//Inhalt des Textfelds wird auf "" gesetzt
			Anz.setBackground(Color.gray);	//Hintergrundfarbe: grau
			on = false;		//on wird auf false gesetzt
			wert = "0.0";		//wert wird "0.0" gesetzt
			wert1 = 0.0;		//wert1 wird 0.0 gesetzt
	//Die Funktion param wird aufgerufen und somit globale Booleanvariablen verändert.
	//Näheres über diese Funktion weiter unten bei der Funktion
			param(false,false,false);
			laeuft = false;		//laeuft wird auf false gesetzt.
			p_id = false;
   		pi_id = false;
	//Wenn die Zeichenkette str nicht gleich "+/-" und nicht gleich "on", dann
		}else{
	//switch-Schleife, die je nachdem welche Taste gedrückt ist, der Funktion rechne()
	//die richtigen Werte übergibt
			switch(Zeichen){
				case '*':
					rechne("*",'o'); //o für operator
				break;
				case '/':
					rechne("/",'o');
				break;
				case '+':
					rechne("+",'o');
				break;
				case '-':
					rechne("-",'o');
				break;
				case '.':
					if(!p_id){
						p_id = true;				
						rechne(".",'p'); //p für punkt
					}
				break;
				case 'p': //'pi'
					if(!pi_id){
						pi_id = true;						
						rechne(Double.toString(Math.PI).substring(0,12),'z'); //z für Zahl
					}
				break;
				case 'A': //'ANS'
					rechne(Double.toString(store),'s'); //s für Speicher
				break;
				case 'C':
					rechne("C",'c'); //c für Clear
				break;
				case '=':
					rechne("=",'i'); //i für ist gleich
				break;
				default:
					rechne(String.valueOf(str),'z'); //z für Zahl
				break;
			}
		}
	//Wenn on nicht wahr ist, wird dieser else-Teil der Schleife ausgeführt
	}else{
	//Wenn str (Also die Beschriftung des Buttons) "on" ist, dann wird diese if-Schleife ausgeführt
		if(str == "on"){
			Anz.setBackground(Color.white); //weißer Hintergrund
			on = true;			//on wird auf true gesetzt
			wert = "0.0";			//wert wird auf "0.0" gesetzt
			Anz.setText(wert);		//das Textfeld wird mit wert gefüllt
		}
	}
  }
  
	//Wird benötigt, da MouseListener im Applet implementiert ist.
	//Wird bei einem Mausklick aufgerufen (Drücken und sofort loslassen)
  public void mouseClicked(MouseEvent e) { }
  	//Wird benötigt, da MouseListener im Applet implementiert ist.
	//Wird bei einem Auf-die-Maus-drücken (und nicht mehr loslassen) aufgerufen
  public void mousePressed(MouseEvent e) { 
  	if(titell("xy",e)) {
		//Wenn Die Funktion titell() einen Wahren Wert zurückgibt, dann soll ein schwarzes
		//Rechteck in der Größe des Taschenrechners gemalt werden.
		Rand = true;
		drag = true;
		//Neu zeichnen, damit Änderungen aktiv werden.
		repaint();
	}
  }
	//Wird benötigt, da MouseListener im Applet implementiert ist.
	//wird beim loslassen der Maustaste aufgerufen
  public void mouseReleased(MouseEvent e) {
  	//drag wird wieder auf falsch gesetzt, da der Mauszeiger losgelassen wurde.
  	dragfirst = false;
	drag = false;
	Rand = false;
	//Neu zeichnen, damit Änderungen aktiv werden.
	repaint();
  }
	//Wird benötigt, da MouseListener im Applet implementiert ist.
	//wird aufgerufen, wenn die Maus über ein Objekt bewegt wird
  public void mouseEntered(MouseEvent e) { }
	//Wird benötigt, da MouseListener im Applet implementiert ist.  
	//wird aufgerufen, wenn die Maus von dem Object wieder herunterbewegt wird
  public void mouseExited(MouseEvent e) { }
  
	//Wird benötigt, da MouseMotionListener im Applet implementiert ist.
	//wird aufgerufen, wenn die Maus mit gedrückter Maustaste bewegt wird (draggen)
  public void mouseDragged(MouseEvent e) {
  	//Wenn drag gleich true, dann
  	if(drag) {
	//Wenn der Mauszeiger noch nicht gedrückt wurde, dann werden die Werte die der Zeiger
	//in dem Moment hat gespeichert und drag auf wahr gesetzt.
		if(!dragfirst){
			DX = e.getX();	//DX wird der aktuelle X-Wert des Mauszeigers zugewiesen
			DY = e.getY();	//DY wird der akt. Y-Wert des Mausz. zugewiesen
			Xi = X;		//Xi wird gleich X gesetzt
			Yi = Y;		//Yi wird gleich Y gesetzt
			dragfirst = true;
		}
	//x und y sind die Differenzen aus dem aktuellem X/Y-Wert und dem letzten Anfasspunkt
	//des Mauszeigers an dem Rechner
		int x = (e.getX() - DX);
		int y = (e.getY() - DY);
		
	//Xi und Yi sind imaginäre X und Y-Werte, die überallhin bewegt werden dürfen.
		Xi = Xi + x;
		Yi = Yi + y;
		
	//Wenn die Xi und Yi-Werte sich innerhalb der Applet-Grenzen bewegen, werden
	//die X und Y-Werte gleichgesetzt, andernfalls wird festgestellt, wo diese die Grenzen
	//des Applets überschreiten und demnach die X und Y Werte auf ihre jeweiligen Maxima gesetzt.
		if(Xi < (Breite - W) && Xi > 0) X = Xi;
		else{
			if(Xi > (Breite - W)) X = Breite - W;
			if(Xi < 0) X = 0;
		}
		if(Yi < (Hoehe - H) && Yi > 0) Y = Yi;
		else{
			if(Yi > (Hoehe - H)) Y = Hoehe - H;
			if(Yi < 0) Y = 0;
		}
	
	//Die DX/DY-Werte werden aktualisiert
		DX = e.getX();
		DY = e.getY();
		
	//Neu zeichnen, damit Änderungen aktiv werden
		repaint();
	}
  }
  	//Wird benötigt, da MouseMotionListener im Applet implementiert ist.
  	//wird aufgerufen, wenn die Maus bewegt wird
  public void mouseMoved(MouseEvent e){ }
  
  public boolean titell(String value, MouseEvent e){
  	//Wenn Die Maus innerhalb der Titelleiste (Breite: W, Höhe: TH) liegt, dann gibt diese Funktion
	//true, ansonsten false zurück, wobei
	//wenn value gleich xy, dann wird überprüft ob die Maus mit dem X UND dem Y-Wert innerhalb
	//der Titelleiste ist.
	//bei value == x, ob die Maus mit dem X-Wert innerhalb der Titelleiste ist und bei
	//value == y, ob die Maus mit dem Y-Wert innerhalb der Titelleiste ist.
	
	//Wenn value gleich "xy", dann ...
  	if(value == "xy") {
	//wenn wahr dann wird true zurückgegeben, ansonsten false;
		if(e.getX() >= X && e.getX() <= (X + W) && e.getY() >= Y && e.getY() <= (Y + TH)) return true;
		else return false;
	//Wenn value nicht gleich "xy", aber gleich "x", dann ...
	}else if(value == "x"){
	//wenn wahr dann wird true zurückgegeben, ansonsten false;
		if(e.getX() >= X && e.getX() <= (X + W)) return true;
		else return false;
	//Wenn value nicht gleich "xy" und nicht gleich "x", aber gleich "y", dann ...
	}else if(value == "y"){
	//wenn wahr dann wird true zurückgegeben, ansonsten false;
		if(e.getY() >= Y && e.getY() <= (Y + TH)) return true;
		else return false;	
	//Wenn value nicht gleich "xy" und nicht gleich "x" und nicht gleich "y", dann ...
	}else return false;
  }
  
  	//Wird automatisch durch die Funktion repaint() aufgerufen, die z.B. wiederum beim Appletstart
  	//automatisch aufgerufen wird
  public void paint(Graphics g){
	g.setColor(winblue);		//Farbe auf Grau setzen
	//Ein ausgefülltes Rechteck malen: (X-Wert,Y-Wert,Breite,Höhe)
	g.fillRect(X,Y,W,H); 	
	g.setColor(Color.white); 	//Titelleiste weiß ausmalen
	g.fillRect(X,Y,W,TH);
	//Ein Bild über die aktuelle Titelleiste malen: (Bild,X-Wert,Y-Wert,Verweis auf den aktuellen
	//Container [Applet]).
	img = getImage(getCodeBase(),"folder.gif");
	g.drawImage(img,X,Y,this);
	
	//Die Positon, von P werden auf die aktuellen X und Y-Werte verändert
	P.setLocation(X+1,Y+TH+5+1);	
	
	//Wenn Rand = true, dann wird ein schwarzer Rand um den Rechner gemalt
	if(Rand){
		g.setColor(Color.black);
		g.drawRect(X,Y,W,H);
	}
	//Die Farbe wird auf weiß gesetzt, ein neuer Font erzeugt, der Font gesetzt und die
	//Titelleiste beschriftet
	g.setColor(Color.white);
	Font f = new Font("Courier", Font.PLAIN, 14);
	g.setFont(f);
	g.drawString("Tom's Rechner",X+100,Y+17);
  }

  	//rechne(): Funktion fürs Rechnen mit value: Art des Zeichens
  	//und type: u für umschalten plus/minus o für operator, p für punkt, 3 für pi (3.14),
	//z für Zahl, s für Speicher, c für Clear und i für ist gleich
  public void rechne(String value,char type){ 
	if(error){
		error = false;
		wert = "0.0";
	}
  	//Wenn der Wert(value) eine Zahl ist, dann ...
  	if(type == 'z'){
	//2 boolean-Variablen, die true gesetzt werden, wenn wert oder value gleich pi ist
		if(!o_p){			
			if(!p_p && !z_p) wert = value;
	   	else if(!pi_id) wert += value;
		   	  else wert = value;
		}else{
			wert1 = Double.valueOf(wert).doubleValue();
			wert = value;
		}
		param(false,false,true);
	}
	//Wenn der Wert(value) ein Punkt ist, dann ...
	if(type == 'p'){
	//Wenn vorher nicht auf den Punkt gedrückt wurde, und jetzt auch nicht auf pi, dann ...
		if(!p_p && !pi_id){
			if(!z_p){
				wert1 = Double.valueOf(wert).doubleValue();
				wert = "0.";
			}else wert += ".";
			param(false,true,false);
		}
	//Wenn der Wert(value) kein Punkt ist, dann wird die switch-Schleife aufgerufenm die je nach
	//Typ des Wertes (value) reagiert
	}else	switch (type){
	//Falls der Typ u (Umschalter +/-):
			case 'u':
				wert = Double.toString(Double.valueOf(wert).doubleValue() * -1);
				param(false,false,false);
			break;
	//Falls der Typ o (Operator +,-,/,*):
			case 'o':
				if(!o_p){
					if(laeuft) rechne2();					
				}
				opstr = value;
				laeuft = true;
				param(true,false,false);
				p_id = false;
				pi_id = false;
			break;
	//Falls der Typ s (Speicher ANS):
			case 's':	
				wert = Double.toString(store);
				param(false,false,true);
				p_id = false;
				pi_id = false;
			break;
	//Falls der Typ c (Clear):
			case 'c':
				wert = "0.0";
				wert1 = Double.valueOf("0.0").doubleValue();
				laeuft = false;
				param(false,false,false);
				p_id = false;
				pi_id = false;
			break;
	//Falls der Typ i (ist-gleich):
			case 'i':
				rechne2();
				if(error) store = 0.0;
				else store = Double.valueOf(wert).doubleValue();
				laeuft = false;
				param(false,false,false);
				p_id = false;
				pi_id = false;
				wert1 = 0.0;
			break;
		}
	Anz.setText(wert);	//Das Textfeld auf wert verändern
  }
  
	//Die Funktion param, die die globalen boolean-Werte o_p, p_p und z_p setzt.
	//Der einzige Sinn dieser Funktion ist, dass der Code übersichtlicher bleibt,
	//da durch dieser Funktion 3 Zeilen auf eine reduziert wurden.
	//Das ist natürlich nur sinnvoll, wenn diese 3 Zeilen, wie hier, häufig benötigt werden
  public void param(boolean operator_pressed,boolean point_pressed,boolean zahl_pressed){
  	if(operator_pressed) o_p = true;
	else o_p = false;
	if(point_pressed) p_p = true;
	else p_p = false;
	if(zahl_pressed) z_p = true;
	else z_p = false;
  }

	//Die Funktion rechne2 erledigt die eigentliche Rechenarbeit:
  public void rechne2(){
  	//Damit man die switch-Funktion verwenden kann, wird wieder das erste Zeichen von
	//opstr (Das den zuletzt gedrückten Operator enthält) als ASCII - Wert in die
	//Variable op geschrieben.
	char op = opstr.charAt(0);
	//Die jeweilige Funktion wird aufgerufen und das Ergebnis berechnet und
	//wert dementsprechend gesetzt
	
	double Wert = 0.0;
	switch (op){
		case '+':
			//Double.valueOf(String s).doubleValue() kann jeden numerischen Wert
			//von String zu double umwandeln.
			Wert = wert1 + Double.valueOf(wert).doubleValue();
		break;
		case '-':
			Wert = wert1 - Double.valueOf(wert).doubleValue();
		break;
		case '*':
			Wert = wert1 * Double.valueOf(wert).doubleValue();
		break;
		case '/':
			if(Double.valueOf(wert).doubleValue() != 0.0)
				Wert = wert1 / Double.valueOf(wert).doubleValue();
			else error = true;
		break;
	}
	//Wenn kein Division-durch-Null-Fehler erfolgte, dann ...
	if(!error){
	//Der sich ergebene Wert wird im DecimalFormat (Jeweils vor dem Kommma maximal 10 und nach dem Komma
	//maximal 10 Stellen) formatiert und dem String wert zugewiesen.
		DecimalFormat df = new DecimalFormat("#########0.00########");
	
		DecimalFormatSymbols dfs = new DecimalFormatSymbols(java.util.Locale.US);
		df.setDecimalFormatSymbols(dfs);
	
	//Der double-Wert wird ins DecimalFormat umgewandelt, von dort wieder ins double-Format, um evtl. die Nullen
	//am Ende zu entfernen und dann wieder ins DeciamlFormat und von dort dem String wert zugewiesen
		wert = df.format(Double.valueOf(df.format(Wert)).doubleValue());
	//Wenn ein Divisioin-durch-Null-Fehler vorliegt, dann ...	
	}else wert = "ERROR: DIV/0!";
  }
}