#! /usr/bin/python

# BRUCHRECHNUNG - Einführung in objektorientiertes Programmieren
# Datei: teil_mvctest6.py
# mit grafischer Programmsteuerung (GUI)
#	Autor: Bombei, Juni 2002, F-Ebert-Oberschule
#	Quelle: Kokavecz, Okt.2000

import Tkinter
from Tkconstants   import  *
from bruch_fach6   import  Bruch, Dia_Bruch

class xBruch:
   """
   /* GUI-Darstellung eines Bruches
   """
   def __init__(self,win):
      """
      /* Zwei Eingabefelder werden übereinander angeordnet (Zähler,Nenner).
      /* Links daneben jeweils eine Beschriftung  .
      /* win kennzeichnet das Parent-Objekt, in das der Bruch gesetzt wird.
      """
      zWert = Tkinter.StringVar()
      RaLinks   = Tkinter.Frame(win)
      RaLinks.pack(side=LEFT)
      RaRechts  = Tkinter.Frame(win)
      RaRechts.pack(side=LEFT)
      LaZaehler = Tkinter.Label(RaLinks, text= "Zähler ")
      LaZaehler.pack()
      LaNenner = Tkinter.Label(RaLinks, text= "Nenner ")
      LaNenner.pack()
      self.zaehler=Tkinter.Entry(RaRechts,textvariable=zWert, width=5)
      self.zaehler.pack(padx=4, pady=4)
      nWert=Tkinter.StringVar()
      self.nenner=Tkinter.Entry(RaRechts,textvariable=nWert, width=5)
      self.nenner.pack(padx=4, pady=4)

   def get_xZaehler(self):
      """
      /* liefert den eingegebenen Wert aus dem Zähler-Eingabefeld
      """
      Eing = self.zaehler.get()
      if Eing == "" :
           Eing = "0"
      return int(Eing)

   def get_xNenner(self):
      """
      /* liefert den eingegebenen Wert aus dem Nenner-Eingabefeld 
      """
      Eing = self.nenner.get()
      if Eing == "" :
           Eing = "1"
      return int(Eing)

   def set_xZaehler(self,wert):
      """
      /* Vorbesetzung des Zähler-Eingabefeldes mit einem Wert
      """
      self.zaehler.delete(0,END)
      self.zaehler.insert(0,wert)

   def set_xNenner(self,wert):
      """
      /* Vorbesetzung des Nenner-Eingabefeldes mit einem Wert
      """
      self.nenner.delete(0,END)
      self.nenner.insert(0,wert)         

class xZahl:
   """
   /* GUI-Darstellung einer Zahleneingabe
   """
   def __init__(self,win):
      """
      /* Ein Zahlen Eingabefeld wird angelegt
      /* win kennzeichnet das Parent-Objekt, in das die Zahl gesetzt wird.
      """
      zWert=Tkinter.StringVar()
      self.zahl=Tkinter.Entry(win,textvariable=zWert, width=5)
      self.zahl.pack(padx=4, pady=4)

   def get_xZahl(self):
      """
      /* liefert den eingegebenen Wert aus dem Zahl-Eingabefeld
      """
      Eing = self.zahl.get()
      if Eing == "" :
           Eing = "1"
      return int(Eing)

   def set_xZahl(self,wert):
      """
      /* Vorbesetzung des Zahl-Eingabefeldes mit einem Wert
      """
      self.zahl.delete(0,END)
      self.zahl.insert(0,wert)


class xTaste:
   """
   /* GUI-Darstellung einer Taste
   """
   def __init__(self, win, Text, Bef, Seite=TOP):
      """
      /* win kennzeichnet das Parent-Objekt, in das die Taste gesetzt wird.
      /* Text : string : Beschriftung der Taste
      /* Bef  : Methodenreferenz : Methode, die beim Drücken der Taste 
      /*                           ausgeführt werden soll.
      /* Seite: option. Parameter, um Tasten auch nebeneinander anordnen zu können
      """
      Knopf=Tkinter.Button(win, text=Text, command=Bef)
      Knopf.pack(side=Seite, padx=4, pady=4, fill=X, expand=1)

class xRechner6:
   """
   /* GUI-Darstellung des Rechners
   """
   def __init__(self,Rechner):
      """
      /* Bei der Objekterzeugung wird ein Fenster mit dem Rechner
      /* geöffnet
      /* Rechner: Referenz auf ein Objekt der Klasse Dia_Bruch
      """
      # Bezüge zum Fachkonzept:
      self.Rechner=Rechner
      self.Rechner2=Bruch()

      # Hauptfenster erstellen:
      dasFenster=Tkinter.Tk()
      dasFenster.geometry("+100+50")
      dasFenster.title("Bruchrechner Test 6")

      #Grobe Rahmenstruktur:
      RahmenOben=Tkinter.Frame(dasFenster, bd=2)
      RahmenOben.pack(padx=4, pady=4)
      RahmenMitte=Tkinter.Frame(dasFenster, bd=2)
      RahmenMitte.pack(padx=4, pady=4)
      RahmenUnten=Tkinter.Frame(dasFenster, bd=2)
      RahmenUnten.pack(padx=4, pady=4, fill=X, expand=1)
      RahmenGanzUnten=Tkinter.Frame(dasFenster, bd=2)
      RahmenGanzUnten.pack(padx=4, pady=4)

      # Unterteilende Rahmen, jeweils mit Beschriftung:
      RahmenBr1 = Tkinter.Frame(RahmenOben, relief=SUNKEN, bd=2)
      RahmenBr1.pack(side=LEFT, padx=4, pady=6, fill=Y, expand=1)
      RBr1Text  = Tkinter.Label(RahmenBr1,text=" Eingabe Bruch 1 ")
      RBr1Text.pack()

      RahmenErg=Tkinter.Frame(RahmenOben, relief=SUNKEN, bd=2)
      RahmenErg.pack(side=LEFT, padx=4, pady=6)
      RErgText = Tkinter.Label(RahmenErg,text=" Ergebnis ")
      RErgText.pack()
      RahmenBrEr=Tkinter.Frame(RahmenErg, relief=RIDGE, bd=2)
      RahmenBrEr.pack(padx=4, pady=6)

      RahmenDez=Tkinter.Frame(RahmenErg, relief=RIDGE, bd=2)
      RahmenDez.pack(padx=4, pady=6)
      RDezText = Tkinter.Label(RahmenDez,text=" Dezimal ")
      RDezText.pack(side=LEFT, pady=6)

      RahmenMi=Tkinter.Frame(RahmenErg, relief=RIDGE, bd=2)
      RahmenMi.pack(padx=4, pady=6)
      RMiText = Tkinter.Label(RahmenMi,text=" Mischbruch ")
      RMiText.pack(side=LEFT, pady=6)

      RahmenMona=Tkinter.Frame(RahmenMitte, relief=RIDGE, bd=2)
      RahmenMona.pack(padx=4, pady=6)
      RMonaText = Tkinter.Label(RahmenMona,text=" Unäre Operationen ")
      RMonaText.pack()
      RahmenUnOp=Tkinter.Frame(RahmenMona)
      RahmenUnOp.pack(side=LEFT, padx=4, pady=6)

      RahmenUnEing=Tkinter.Frame(RahmenMona, relief=SUNKEN, bd=2)
      RahmenUnEing.pack(side=LEFT, padx=4, pady=6)
      REingText = Tkinter.Label(RahmenUnEing,text=" Eingabe Zahl ")
      REingText.pack()

      RahmenDiad=Tkinter.Frame(RahmenUnten, relief=RIDGE, bd=2)
      RahmenDiad.pack(padx=4, pady=6, fill=X, expand=1)
      RDiadText = Tkinter.Label(RahmenDiad,text=" Binäre Operationen ")
      RDiadText.pack()
      RahmenBinOp=Tkinter.Frame(RahmenDiad, bd=2)
      RahmenBinOp.pack(side=LEFT, padx=4, pady=6)

      RahmenBr2=Tkinter.Frame(RahmenDiad, relief=SUNKEN, bd=2)
      RahmenBr2.pack(side=LEFT, padx=4, pady=6, fill=Y, expand=1)
      RBr2Text = Tkinter.Label(RahmenBr2,text=" Eingabe Bruch 2 ")
      RBr2Text.pack()

      # Ein- und Ausgabefelder:
      self.Br1  = xBruch(RahmenBr1)
      self.Br2  = xBruch(RahmenBr2)
      self.Zahl = xZahl(RahmenUnEing)
      self.BrEr = xBruch(RahmenBrEr)
      self.Dezi = xZahl(RahmenDez)
      self.MiBr = xZahl(RahmenMi)

      # Aktionstasten:
      KKehrw = xTaste(RahmenUnOp,' Kehrwert ',self.umkehren)
      KErMi  = xTaste(RahmenUnOp,' erweitern mit ',self.erweitern_mit)

      KPlus  = xTaste(RahmenBinOp,' + ',self.plus)
      KMal   = xTaste(RahmenBinOp,' x ',self.mal)

      KLeer = xTaste(RahmenGanzUnten,' zurücksetzen ',self.leeren, LEFT)
      KEnde = xTaste(RahmenGanzUnten,' E N D E ', dasFenster.destroy, LEFT)

   def _einlesen(self, derBruch, xBruch):
      """
      /* interne Methode,
      /* übergibt GUI-Bruch-Eingaben (xBruch) an Fachkonzept (derBruch)
      """
      derBruch.setze_zaehler(xBruch.get_xZaehler())
      derBruch.setze_nenner(xBruch.get_xNenner())

   def _anzeigen(self):
      """
      /* interne Methode, holt GUI-Bruch-Anzeige aus Fachkonzept
      """
      self.BrEr.set_xZaehler(self.Rechner.gib_zaehler())
      self.BrEr.set_xNenner(self.Rechner.gib_nenner())
      self.Dezi.set_xZahl(self.Rechner.gib_dezimalwert())
      self.MiBr.set_xZahl(self.Rechner.gib_mischbruch())

   def erweitern_mit(self):
      """
      /* Methode, die beim Drücken der Erweitern-Taste aufgerufen wird
      """
      self._einlesen(self.Rechner,self.Br1)
      self.Rechner.erweitern_mit(self.Zahl.get_xZahl())
      self._anzeigen()

   def umkehren(self):
      """
      /* Methode, die beim Drücken der Kehrwert-Taste aufgerufen wird
      """
      self._einlesen(self.Rechner,self.Br1)
      self.Rechner.bilde_kehrwert()
      self._anzeigen()

   def plus(self):
      """
      /* Methode, die beim Drücken der Plus-Taste aufgerufen wird
      """
      self._einlesen(self.Rechner,self.Br1)
      self._einlesen(self.Rechner2,self.Br2)
      self.Rechner.addieren(self.Rechner2)
      self._anzeigen()

   def mal(self):
      """
      /* Methode, die beim Drücken der Mal-Taste aufgerufen wird
      """
      self._einlesen(self.Rechner,self.Br1)
      self._einlesen(self.Rechner2,self.Br2)
      self.Rechner.multiplizieren(self.Rechner2)
      self._anzeigen()

   def leeren(self):
      """
      /* Methode, die beim Drücken der Zurücksetzen-Taste aufgerufen wird
      """
      self.Br1.set_xZaehler("")
      self.Br1.set_xNenner("")
      self.Br2.set_xZaehler("")
      self.Br2.set_xNenner("")
      self.BrEr.set_xZaehler("")
      self.BrEr.set_xNenner("")
      self.Zahl.set_xZahl("")
      self.Dezi.set_xZahl("")
      self.MiBr.set_xZahl("")


if __name__ == "__main__":
   meinRechner=Dia_Bruch()
   meinWindow=xRechner6(meinRechner)
   Tkinter.mainloop()