Tinnitus_Musik_Therapie_Projektarbeit_Repo/TinnitusAnalyse/TinnitusAnalyse_GUI.py

from tkinter import filedialog
from tkinter.ttk import Frame, Label, Button, LabelFrame, Combobox, Style, Checkbutton, Entry, Panedwindow, Separator
from tkinter import *
from SoundGenerator import *
import sounddevice as sd
from scipy.io import wavfile
import threading

"""--------------------------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:
            unten_button_stop_press()  # Wiedergabe beenden, durch den Rechenaufwand gibt es sonst Wiedergabeprobleme
            tinnitus.vorname = untenEntryVorname.get()
            tinnitus.nachname = untenEntryNachname.get()
            tinnitus.kommentar = untenTextKommentar.get("1.0", END)
            tinnitus.speichern()
            feedback("Speichere Sound als '.wav'-Datei. Bitte warten...")
            sound.wav_speichern()
            feedback("Daten erfolgreich gespeichert. Siehe: " + sound.wav_name, "white", "green")
        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


def unten_button_musikdatei_laden_press():
    """ This function opends a window that lets you select .mp3 and .wav files. The user is supposed to select their
    music files here"""
    print("button musikdatei laden pressed")

    untererFrame.musikdatei = filedialog.askopenfilename(initialdir="/",
                                                         title="Wähle die Musikdatei(.wav) deiner Wahl aus",
                                                         filetypes=(("wav Dateien", "*.wav"),))

    samplerate, data = wavfile.read(untererFrame.musikdatei)

    sound.music_samplerate = samplerate # die samplerate der ausgewählten Musikdatei an SoundGenerator.py übergeben
    sound.music_data = data    # das Numpy Array der ausgewählten Musikdatei an SoundGenerator.py übergeben

    print(untererFrame.musikdatei)
    untenTextMusikDatei.config(state=NORMAL)      # activate text field (otherwise it is readonly)
    untenTextMusikDatei.delete(1.0, END)    # delete everything from text widget
    untenTextMusikDatei.insert(INSERT, untererFrame.musikdatei)     # insert selected file path to text widget
    untenTextMusikDatei.config(state=DISABLED)  # activate text field (otherwise it is readonly)

    feedback("Musikdatei ausgewählt")  # place text in feedback field, fontcololor, backgroundcolor


def unten_button_filtere_tinnitus_aus_musik():
    print("button filtere tinnitus aus musik pressed")
    print(untenTextMusikDatei.get('1.0', END))
    if untenTextMusikDatei.get('1.0', END) == "Einen Song deiner Wahl hier auswählen\n":
        feedback("Wähle zuerst eine Musikdatei aus", "white", "red")
    else:
        unten_button_stop_press()  # Wiedergabe beenden, durch den Rechenaufwand gibt es sonst Wiedergabeprobleme
        feedback("Starte Filtervorgang (dies kann etwas dauern)...", "blue")

        try:
            # Filtern in extra thread, damit sich die GUI nicht aufhängt: (daemon beendet den Thread, wenn das Hauptprogramm beendet wird)
            filter_thread = threading.Thread(target=sound.musik_filtern, daemon=True)
            filter_thread.start()

            safe_percentage = 0
            schritt = 0
            while filter_thread.is_alive():
                schritt_alt = schritt
                schritt = sound.filterfortschritt[0]
                if schritt > schritt_alt:  # Prozentanzeige auf 0 zurücksetzen, wenn ein neuer Schritt beginnt
                    safe_percentage = 0
                if schritt == 3 or schritt == 4: # Nur bei dem 3. und 4. Schritt wird der Fortschritt in Prozent angezeigt
                    fb = "Schritt " + str(schritt) + " von 4 (" + str(safe_percentage) + "%)"
                    if sound.filterfortschritt[1] > safe_percentage:
                        feedback(fb)
                        safe_percentage += 10
                elif schritt < 3 and schritt > schritt_alt:
                    fb = "Schritt " + str(schritt) + " von 4"
                    feedback(fb)

                root.update()  # damit die GUI nicht eingefroren erscheint

            if sound.filterfortschritt[0] == 5:  #ist 5, wenn erfolgreich gefiltert wurde
                print("-- filtern beendet --")
                feedback("Filtervorgang erfolgreich abgeschlossen. \n"
                        "Audiodatei unter dem Namen MyTinnitusFreeSong.wav erstellt", "white", "green")
            else:
                print("Fehler bei Filterfunktion. Siehe Compiler-Meldungen")
                feedback("Fehlgeschlagener Filterversuch. Kontaktiere Entwickler und schreibe eventuell auf was genaud du gemacht hast", "red", "white")
        except:
            feedback("Fehlgeschlagener Filterversuch. Drücke zuerst den Speichern Knopf"
                     "Stelle sicher, dass die Lautstärke mindestens einer Seite über 0"
                     "gestellt ist. Sonst gehen wir davon aus, dass auf diesem Ohr kein Tinnitus vorliegt.", "red",
                     "white")

""" 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 + S))

#----------- PLAY BUTTON
untenButtonPlay = Button(untererFrame, text="PLAY", font="bold", relief="raised", bg="green", fg="white",
                         command=unten_button_play_press)
untenButtonPlay.grid(column=7, 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=8, 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)
untenLabelKommentar = Label(untererFrame, text="(optional)")
untenLabelKommentar.grid(column=0, row=5, sticky=N)
untenTextKommentar = Text(untererFrame, height=10, width=60)  # create a field where u can enter text
untenTextKommentar.grid(column=1, row=4, sticky=W, 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+E+W))


"""--------------------------------------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


# -------------- LOAD MUSIC FILE--------------
untenTextMusikDatei = Text(untererFrame, height=1, width=50)
untenTextMusikDatei.grid(column=1, row=7,  sticky=(N+S+E+W), columnspan=4)
untenTextMusikDatei.insert(INSERT, "Einen Song deiner Wahl hier auswählen")     # insert selected file path to text widget
untenTextMusikDatei.config(state=DISABLED, font=("Arial", 8))  # activate text field (otherwise it is readonly)

untenButtonMusikDateiLaden = Button(untererFrame, text="Musikdatei auswählen",
                                    command=unten_button_musikdatei_laden_press)
untenButtonMusikDateiLaden.grid(column=4, row=7, sticky=(N+S+E+W))


#------------BUTTON FILTERE TINNITUS AUS MUSIK-----------------
untenButtonFiltereTinnitusAusMusik = Button(untererFrame, text="Filtere Tinnitus-Frequenzen aus Musik",
                                            command=unten_button_filtere_tinnitus_aus_musik, font="bold",
                                            relief="raised", bg="blue", fg="white",)
untenButtonFiltereTinnitusAusMusik.grid(column=3, row=9, sticky=(N+S+E+W), columnspan=3)


root.mainloop()