Tinnitus_Musik_Therapie_Projektarbeit_Repo/TinnitusAnalyse/TinnitusAnalyse_GUI.py

from tkinter.ttk import Frame, Label, Button, LabelFrame, Combobox, Style, Checkbutton, Entry, Panedwindow, Separator
from tkinter import *
from SoundGenerator import *
import csv
import time
#todo: in die Obere/untere Grenz Scale cghange Funktionen sicher gehen, dass keine Fehler mehr auftreten (zB :og < ug)

"""--------------------------FUNKTIONEN DIE DURCH GUI KLICKS AUSGEFÜHRT WERDEN---------------------------------------"""
"""-------Funktionen links-------------"""


def links_scale_lautstärke_change(self):
    tinnitus.linksLautstaerke = float(linksScaleLautstärke.get())/100   # scale liefert 0-100%, tinnitus.lautstärke 0-1
    print("Links Lautstärke =", tinnitus.linksLautstaerke*100, "%")
    sound.play()


def links_scale_frequenz_change(self):
    tinnitus.linksFrequenz = float(linksScaleFrequenz.get())*1000    # scale liefert 20-20kHz, tinnitus.frequenz in Hz
    print("Links Frequenz = ", tinnitus.linksFrequenz, " Hz")
    sound.play()


def links_scale_rauschen_lautstärke_change(self):
    # scale liefert 0-100%, tinnitus.lautstärke zwischen 0-1 (float)
    tinnitus.linksRauschenLautstaerke = float(linksScaleRauschenLautstärke.get()/1000)
    print("Links Rauschen Lautstärke = ", tinnitus.linksRauschenLautstaerke*1000, "%")
    sound.play()


def links_scale_untere_grenzfrequenz_change(self):
    og = float(linksScaleObereGrenzfrequenz.get() * 1000)  # kHz -> Hz
    ug = float(linksScaleUntereGrenzfrequenz.get() * 1000)  # kHz -> Hz
    if og <= ug:  # wenn obere Grenzfreq. kleiner als untere Grenzfreq. ist -> macht keinen Sinn deswegen verbieten
        linksScaleUntereGrenzfrequenz.set(linksScaleObereGrenzfrequenz.get() - 0.01)
    else:
        tinnitus.linksRauschenUntereGrenzfrequenz = ug
        sound.play()


def links_scale_obere_grenzfrequenz_change(self):
    og = float(linksScaleObereGrenzfrequenz.get()*1000)    # kHz -> Hz
    ug = float(linksScaleUntereGrenzfrequenz.get() * 1000)  # kHz -> Hz
    if og <= ug:  # wenn obere Grenzfreq. kleiner als untere Grenzfreq. ist -> macht keinen Sinn deswegen verbieten
        linksScaleObereGrenzfrequenz.set(linksScaleUntereGrenzfrequenz.get() + 0.01)
    else:
        tinnitus.linksRauschenObereGrenzfrequenz = og
        sound.play()


"""----------Funktionen rechts----------"""


def rechts_scale_lautstärke_change(self):
    tinnitus.rechtsLautstaerke = float(rechtsScaleLautstärke.get()/100)
    print("Rechts Lautstärke =", tinnitus.rechtsLautstaerke, "%")
    sound.play()


def rechts_scale_frequenz_change(self):
    tinnitus.rechtsFrequenz = float(rechtsScaleFrequenz.get()*1000)
    print("Rechts Frequenz= ", tinnitus.rechtsFrequenz, " Hz")
    sound.play()


def rechts_scale_rauschen_lautstärke_change(self):
    tinnitus.rechtsRauschenLautstaerke = float(rechtsScaleRauschenLautstärke.get()/1000)    # 0-100% -> 0-1(float)
    print("Rechts Rauschen Lautstärke = ", tinnitus.rechtsRauschenLautstaerke*1000, "%")
    sound.play()


def rechts_scale_untere_grenzfrequenz_change(self):
    og = float(rechtsScaleObereGrenzfrequenz.get() * 1000)  # kHz -> Hz
    ug = float(rechtsScaleUntereGrenzfrequenz.get() * 1000)  # kHz -> Hz
    if ug >= og:     # wenn obere Grenzfreq. kleiner als untere Grenzfreq. ist -> macht keinen Sinn deswegen verbieten
        rechtsScaleUntereGrenzfrequenz.set(rechtsScaleObereGrenzfrequenz.get()-0.01)
    else:
        tinnitus.rechtsRauschenUntereGrenzfrequenz = ug
        sound.play()


def rechts_scale_obere_grenzfrequenz_change(self):
    og = float(rechtsScaleObereGrenzfrequenz.get()*1000)    # kHz -> Hz
    ug = float(rechtsScaleUntereGrenzfrequenz.get() * 1000)  # kHz -> Hz
    if og <= ug:    # wenn obere Grenzfreq. kleiner als untere Grenzfreq. ist -> macht keinen Sinn deswegen verbieten
        rechtsScaleObereGrenzfrequenz.set(rechtsScaleUntereGrenzfrequenz.get()+0.01)
    else:
        tinnitus.rechtsRauschenObereGrenzfrequenz = og
        sound.play()


"""--------------Funktionen unten------------------"""


def unten_button_ohren_synchro():
    auswahl = untenComboOhrenSynchro.get()  # holt die momentane Auswahl aus combobox
    print("Einstellungen von:" + auswahl + " das auf das jeweils andere Ohr setzen")

    if auswahl == "":
        feedback("Bitte wähle ein Ohr", "white", "red")

    if auswahl == "Linkes Ohr":     # linkes --> rechts
        rechtsScaleLautstärke.set(linksScaleLautstärke.get())
        rechtsScaleFrequenz.set(linksScaleFrequenz.get())
        rechtsScaleRauschenLautstärke.set(linksScaleRauschenLautstärke.get())
        rechtsScaleUntereGrenzfrequenz.set(linksScaleUntereGrenzfrequenz.get())
        rechtsScaleObereGrenzfrequenz.set(linksScaleObereGrenzfrequenz.get())
        feedback("Einstellungen vom linken Ohr auf beide Ohren übertragen")

    if auswahl == "Rechtes Ohr":    # rechts --> links
        linksScaleLautstärke.set(rechtsScaleLautstärke.get())
        linksScaleFrequenz.set(rechtsScaleFrequenz.get())
        linksScaleRauschenLautstärke.set(rechtsScaleRauschenLautstärke.get())
        linksScaleUntereGrenzfrequenz.set(rechtsScaleUntereGrenzfrequenz.get())
        linksScaleObereGrenzfrequenz.set(rechtsScaleObereGrenzfrequenz.get())
        feedback("Einstellungen vom rechten Ohr auf beide Ohren übertragen")


def unten_button_speichern_press():
    print("button speichern pressed")
    # Wenn man Speichern will bevor ein Name eingegeben wurde kann man nicht speichern
    if (not untenEntryVorname.get()) or (not untenEntryNachname.get()):
        print("fehlgeschlagener Speicherversuch - Keine Eingaben gemacht")
        feedback("Fehlgeschlagener Speicherversuch! Erst Namen links eintragen.", "white", "red")
    else:
        try:
            feedback("Speichere Sound als '.wav'-Datei. Das kann bis zu 30 Sekunden dauern. Bitte warten...")
            tinnitus.vorname = untenEntryVorname.get()
            tinnitus.nachname = untenEntryNachname.get()
            tinnitus.kommentar = untenTextKommentar.get("1.0", END)
            tinnitus.speichern()
            sound.wav_speichern()
            feedback("Daten erfolgreich gespeichert. Siehe: 'MeinTinnitus.wav' ")
        except:
            feedback("Fehlgeschlagener Speicherversuch! Bitte schließe Microsoft Excel.", "white", "red")


def unten_button_play_press():
    print("button play pressed")
    feedback("Starte Audioausgabe...", fontcolor="green")
    sound.mute = False  # when this boolean is set to false no audio can ever play (it`s like a savety switch)
    sound.play()


def unten_button_stop_press():
    print("button stop press")
    feedback("Stoppe Audioausgabe", fontcolor="red")  # place text in feedback field, fontcololor, backgroundcolor
    sound.mute = True
    sound.stop()


def feedback(text, fontcolor="black", backgroundcolor="lightsteelblue"):
    """ This is a helper function. You can give it a string text and it will display it in the feedback frame (bottom
    right of the GUI) in the text widget. The parameter color is also a string and defines the font color. Same with
    background. Honestly this function is way too complicated, but Tkinter has no nicer/easier builtin way of doing the
     coloring nicely """
    feedback.lineCounter += 1   # in order to color the texts nicely we need to count the lines of text we add
    untenFeedbackText.config(state=NORMAL)   # activate text field (otherwise it is readonly)

    if feedback.lineCounter == 12:  # if we reached the end of the text box
        untenFeedbackText.delete("1.0", END)    # just delete everything
        feedback.lineCounter = 1                # and start at line 1 again

    untenFeedbackText.insert(INSERT, text + "\n")   # insert the text
    # these 2 lines just color the text nicely, but Tkinter forces your to first "tag_add" mark it and specify the
    # line number and char number you want to mark. And then "tag_config" change the color of this marked region
    untenFeedbackText.tag_add("Line"+str(feedback.lineCounter), str(feedback.lineCounter)+".0", str(float(len(text))))
    untenFeedbackText.tag_config("Line"+str(feedback.lineCounter), foreground=fontcolor, background=backgroundcolor)

    untenFeedbackText.config(state=DISABLED)     # set the text field back to readonly
    root.update()  #Damit der Text sofort ausgegeben wird, auch wenn das Programm erst noch was anderes macht


""" Initialisierungen """
tinnitus = Tinnitus()    # siehe SoundGenerator.py
sound = Sound(tinnitus)  # siehe SoundGenerator.py
feedback.lineCounter = 0    # Funktionsvariable der Feedback funktion. Ein Funktionsaufruf Counter

"""------------------------------------------ AUFBAU DES ROOT WINDOWS -----------------------------------------------"""
root = Tk()  # build the main window
root.title("Tinnitus Analyse")
root.minsize(width=800, height=500)    # set windowsize (width an height in pixels)
root.resizable(False, False)           # window not resizable (x and y)


"""------------------------------------------LINKER FRAME------------------------------------------------------------"""
linkerFrame = LabelFrame(root, text="Linkes Ohr", font="bold")  # parent is root, padding is extra space at the edges
linkerFrame.grid(column=0, row=0, sticky=(N+W+E+S))  # the frame sticks to every side of the window when resized


linksLautstärke = DoubleVar()
linksFrequenz = DoubleVar()
linksRauschenLautstärke = DoubleVar()
linksRauschenFrequenzband = DoubleVar()

# ------------------ LAUTSTÄRKE ------------------
linksLabelLautstärke = Label(linkerFrame, text="Lautstärke [%]:")
linksLabelLautstärke.grid(column=0, row=0, sticky=W)
linksScaleLautstärke = Scale(linkerFrame, from_=0, to=100, orient=HORIZONTAL, length=600,
                             command=links_scale_lautstärke_change)
linksScaleLautstärke.grid(column=1, row=0, sticky=N+S+W+E)

# -------- FREQUENZ ------------------------
linksLabelFrequenz = Label(linkerFrame, text="Frequenz [kHz]")
linksLabelFrequenz.grid(column=0, row=1,  sticky=W)     # sticky = w(est) makes the text left aligned
linksScaleFrequenz = Scale(linkerFrame, from_=0, to=20,  orient=HORIZONTAL, length=600, resolution=-1.0,
                           command=links_scale_frequenz_change)
linksScaleFrequenz.grid(column=1, row=1, sticky=(W+E))

# ----------- ABTRENNSTRICH ----------------
linksSeparator = Separator(linkerFrame, orient="horizontal")
linksSeparator.grid(column=0, row=2, sticky=(W + E), columnspan=3)

# ----------- RAUSCHEN --------------------
#   Lautstärke
linksLabelRauschenLautstärke = Label(linkerFrame, text="Rauschen Lautstärke %", anchor="w")
linksLabelRauschenLautstärke.grid(column=0, row=3, sticky=W)
linksScaleRauschenLautstärke = Scale(linkerFrame, from_=0, to=100,  orient=HORIZONTAL, length=600,
                                     command=links_scale_rauschen_lautstärke_change)
linksScaleRauschenLautstärke.grid(column=1, row=3, sticky=(W+E))

# Obere Grenzfrequenz
linksLabelObereGrenzfrequenz = Label(linkerFrame, text="Obere Grenzfrequenz [kHz]", anchor="w")
linksLabelObereGrenzfrequenz.grid(column=0, row=4, sticky=W)
linksScaleObereGrenzfrequenz = Scale(linkerFrame, from_=0.02, to=20,  orient=HORIZONTAL, length=600, resolution=-1.0,
                                     command=links_scale_obere_grenzfrequenz_change)
linksScaleObereGrenzfrequenz.grid(column=1, row=4, sticky=(W+E))
linksScaleObereGrenzfrequenz.set(20.00)
# Untere Grenzfrequenz
linksLabelUntereGrenzfrequenz = Label(linkerFrame, text="Untere Grenzfrequenz [kHz]", anchor="w")
linksLabelUntereGrenzfrequenz.grid(column=0, row=5, sticky=(W+E))
linksScaleUntereGrenzfrequenz = Scale(linkerFrame, from_=0.01, to=20,  orient=HORIZONTAL, length=600, resolution=-1.0,
                                      command=links_scale_untere_grenzfrequenz_change)
linksScaleUntereGrenzfrequenz.grid(column=1, row=5, sticky=(W+E))
linksScaleUntereGrenzfrequenz.set(0.01)
"""----------------------------------------------RECHTER FRAME-------------------------------------------------------"""
rechterFrame = LabelFrame(root, text="Rechtes Ohr", font="bold")
rechterFrame.grid(column=1, row=0, sticky=(N+E+W+S))


# Variablen Rechts
rechtsFrequenz = DoubleVar()
rechtsRauschenLautstärke = DoubleVar()
rechtsRauschenFrequenzband = DoubleVar()
rechtsLautstärke = DoubleVar()

# ------------------ LAUTSTÄRKE ------------------
rechtsLabelLautstärke = Label(rechterFrame, text="Lautstärke [%]:")
rechtsLabelLautstärke.grid(column=0, row=0, sticky=W)
rechtsScaleLautstärke = Scale(rechterFrame, from_=0, to=100, orient=HORIZONTAL, length=600,
                             command=rechts_scale_lautstärke_change)
rechtsScaleLautstärke.grid(column=1, row=0, columnspan=10, sticky=W)

# -------- FREQUENZ ------------------------
rechtsLabelFrequenz = Label(rechterFrame, text="Frequenz [kHz]")
rechtsLabelFrequenz.grid(column=0, row=1,  sticky=W)     # sticky = w(est) makes the text left aligned
rechtsScaleFrequenz = Scale(rechterFrame, from_=0, to=20,  orient=HORIZONTAL, length=600, resolution=-1.0,
                            command=rechts_scale_frequenz_change)
rechtsScaleFrequenz.grid(column=1, row=1, columnspan=10, sticky=(W+E))

# ----------- ABTRENNSTRICH ----------------
rechtsSeparator = Separator(rechterFrame, orient="horizontal")
rechtsSeparator.grid(column=0, row=2, columnspan=10, sticky=(W + E))

# ----------- RAUSCHEN --------------------
rechtsLabelRauschenLautstärke = Label(rechterFrame, text="Rauschen Lautstärke %", anchor="w")
rechtsLabelRauschenLautstärke.grid(column=0, row=3, sticky=W)
rechtsScaleRauschenLautstärke = Scale(rechterFrame, from_=0, to=100,  orient=HORIZONTAL, length=600,
                                      command=rechts_scale_rauschen_lautstärke_change)
rechtsScaleRauschenLautstärke.grid(column=1, row=3, sticky=(W+E))

# Obere Grenzfrequenz
rechtsLabelObereGrenzfrequenz = Label(rechterFrame, text="Obere Grenzfrequenz [kHz]", anchor="w")
rechtsLabelObereGrenzfrequenz.grid(column=0, row=4, sticky=W)
rechtsScaleObereGrenzfrequenz = Scale(rechterFrame, from_=0.02, to=20,  orient=HORIZONTAL, length=600, resolution=-1.0,
                                     command=rechts_scale_obere_grenzfrequenz_change)
rechtsScaleObereGrenzfrequenz.grid(column=1, row=4, sticky=(W+E))
rechtsScaleObereGrenzfrequenz.set(20.00)
# Untere Grenzfrequenz
rechtsLabelUntereGrenzfrequenz = Label(rechterFrame, text="Untere Grenzfrequenz [kHz]", anchor="w")
rechtsLabelUntereGrenzfrequenz.grid(column=0, row=5, sticky=(W+E))
rechtsScaleUntereGrenzfrequenz = Scale(rechterFrame, from_=0.01, to=20,  orient=HORIZONTAL, length=600, resolution=-1.0,
                                      command=rechts_scale_untere_grenzfrequenz_change)
rechtsScaleUntereGrenzfrequenz.grid(column=1, row=5, sticky=(W+E))
rechtsScaleUntereGrenzfrequenz.set(0.01)

"""------------------------------------------------ UNTERER LINKER FRAME---------------------------------------------"""
untererFrame = LabelFrame(root, text="Generelles", border=10)
untererFrame.grid(column=0, row=1, sticky=(N + W + S + E))

vorname = StringVar()   # Name des Patienten als String um den generierten Tinnitus später zuordnen zu können
nachname = StringVar()
kommentare = StringVar()    # Ein Feld in dass der Patient noch weitere Kommentare angeben kann
# Den unteren Frame füllen----------------------------------------------------------------------------------------------

# --------- OHREN SYNCHRONISIEREN -----------------------
untenLabelOhrenSynchro = Label(untererFrame, text="Einstellungen von ")
untenLabelOhrenSynchro.grid(column=0, row=0, sticky=(N + W))
untenComboOhrenSynchro = Combobox(untererFrame, values=["Linkes Ohr", "Rechtes Ohr"])
untenComboOhrenSynchro.grid(column=1, row=0, sticky=(N + W + E + S))
untenLabelOhrenSynchro2 = Label(untererFrame, text=" für beide übernehmen")
untenLabelOhrenSynchro2.grid(column=2, row=0, sticky=(N + W + E + S))
untenButtonOhrenSynchro = Button(untererFrame, text="Bestätigen",
                                 command=unten_button_ohren_synchro)
untenButtonOhrenSynchro.grid(column=3, row=0, sticky=(N + W + E + S))

#----------- PLAY BUTTON
untenButtonPlay = Button(untererFrame, text="PLAY", font="bold", relief="raised", bg="green", fg="white",
                         command=unten_button_play_press)
untenButtonPlay.grid(column=8, row=0, sticky=(N + W + E + S))

#------------STOP BUTTON-------------
untenButtonStop = Button(untererFrame, text="STOP", font="bold", relief="raised", bg="red", fg="white",
                         command=unten_button_stop_press)
untenButtonStop.grid(column=9, row=0, sticky=(N + W + E + S))

# ----------- ABTRENNSTRICHE ----------------
untenSeparator = Separator(untererFrame, orient="horizontal")
untenSeparator.grid(column=0, row=1, columnspan=10, sticky=(W + E))

untenSeperator2 = Separator(untererFrame, orient="vertical")
untenSeperator2.grid(column=5, rowspan=5, sticky=N+S)

# ------------NAMENSEINGABE-------------
untenLabelNachname = Label(untererFrame, text="Nachname:")
untenLabelNachname.grid(column=0, row=2, sticky=W)
untenEntryNachname = Entry(untererFrame, textvariable=nachname)
untenEntryNachname.grid(column=1, row=2, sticky=W)
untenLabelVorname = Label(untererFrame, text="Vorname:")
untenLabelVorname.grid(column=0, row=3, sticky=W)
untenEntryVorname = Entry(untererFrame, textvariable=vorname)
untenEntryVorname.grid(column=1, row=3, sticky=W)

# ------------ KOMMENTAR ----------------
untenLabelKommentar = Label(untererFrame, text="weitere Kommentare:")
untenLabelKommentar.grid(column=0, row=4, sticky=W)
untenTextKommentar = Text(untererFrame, height=10, width=50)  # create a field where u can enter text
untenTextKommentar.grid(column=1, row=4, columnspan=3, rowspan=3)

# ----------- SPEICHERN --------------------
untenButtonSpeichern = Button(untererFrame, text="Speichern", font="bold",
                              command=unten_button_speichern_press)
untenButtonSpeichern.grid(column=4, row=6, sticky=S)


"""--------------------------------------UNTERER RECHTER FRAME-------------------------------------------------------"""

untererRechterFrame = LabelFrame(root, text="Programm Feedback")
untererRechterFrame.grid(row=1, column=1, sticky=(N+S+E+W))


# ------------ PROGRAMM OUTPUT ------------
untenFeedbackText = Text(untererRechterFrame, height=13, width=85, bg="lightsteelblue")  # write feedback to patient here
#untenFeedbackText.config(state=DISABLED)    # make the text widget readonly
untenFeedbackText.place(relx=.5, rely=.5, anchor="center")  # the only time I used .place instead of grid, because it
#                                                             lets me place the widget in the middle of the frame



root.mainloop()