ui Module¶

class App(tb.Window):

    def __init__(self, familiarization_func:callable, program_funcs:dict, calibration_funcs:list, progress_func:callable):
        """Creats Main application window. Contains all pages and controls the flow of the program.

        Args:
            familiarization_func (function): function to be called for familiarization
            audiogram_func (function): function to be called for creating audiogram
            program_funcs (dict of str:function): function(s) to be called for the main program
            calibration_funcs (list function): list of function(s) for calibration in this order: start, next, repeat, stop, set_level
        """
        themename = self.get_theme()
        super().__init__(themename=themename)

        # General theme settings
        self.title("Sound Player")
        self.geometry(GEOMETRY)
        self.minsize(650,650)
        self.attributes('-fullscreen', True)
        self.bind("<Escape>", self.exit_fullscreen)

        self.save_path = os.path.join(os.getcwd())

        # Ensure the default save path exists
        os.makedirs(self.save_path, exist_ok=True)

        self.set_icon("Logo_NBG.png") #change the icon maybe? #TODO

        self.tk.call('tk', 'scaling', 2.0)  # Adjust for high-DPI displays

        # Dictionary to store all pages
        self.program_funcs = program_funcs
        self.frames = {}
        self.binaural_test = False

        # Interactive Pages
        for F in (MainMenu, FamiliarizationPage, ProgramPage, ResultPage):
            frame = F(self)
            self.frames[F] = frame
            frame.grid(row=0, column=0, sticky="nsew")

        # Calibration separately to give it its functions
        frame = CalibrationPage(self, calibration_funcs)
        self.frames[CalibrationPage] = frame
        frame.grid(row=0, column=0, sticky="nsew")

        # View during familiarization
        frame = DuringFamiliarizationView(self, familiarization_func, progress_func)
        self.frames[DuringFamiliarizationView] = frame
        frame.grid(row=0, column=0, sticky="nsew")

        # View during programs
        for name, program_func in program_funcs.items():
            frame = DuringProcedureView(self, 
                                        program_func, progress_func,
                                        text="Programm läuft...")
            self.frames[name] = frame
            frame.grid(row=0, column=0, sticky="nsew")

        # Show MainMenu first
        self.show_frame(MainMenu)

        # Create menubar
        self.create_menubar()

        # Variable for threading
        self.process_done = False

        # Override the close button protocol
        self.protocol("WM_DELETE_WINDOW", self.on_closing)

        self.grid_rowconfigure(0, weight=1)
        self.grid_columnconfigure(0, weight=1)

    def create_menubar(self):
        """Creates a menubar with options for changing the theme and exiting the program.
        """
        menubar = tk.Menu(self)
        self.config(menu=menubar)

        file_menu = tk.Menu(menubar, tearoff=0)
        file_menu.add_command(label="Startseite", command=lambda: self.show_frame(MainMenu))
        file_menu.add_command(label="Speicherort ändern", command=self.change_save_path)

        ChangeTheme = tk.Menu(file_menu, tearoff=0)
        ChangeTheme.add_command(label="light", command=lambda: self.change_theme(LIGHT_THEME))
        ChangeTheme.add_command(label="dark", command=lambda: self.change_theme(DARK_THEME))

        file_menu.add_cascade(label="Theme ändern", menu=ChangeTheme)
        file_menu.add_separator()
        file_menu.add_command(label="Programm beenden", command=self.on_closing)

        menubar.add_cascade(label="Einstellungen", menu=file_menu)

    def change_theme(self, theme_name:str):
        """Changes to the specified theme.

        Args:
            theme_name (str): name of the theme to change
        """
        current_theme = self.style.theme_use()

        if current_theme == theme_name:
            messagebox.showwarning("Oops..", "Dieses Theme wird bereits verwendet.")
        else:
            self.style.theme_use(theme_name)

            # change in settings.csv file
            filename = "settings.csv"
            fieldnames = ['file path', 'theme']

            # Read all rows from the settings.csv file
            with open(filename, mode='r', newline='') as file:
                dict_reader = csv.DictReader(file)
                rows = list(dict_reader)

            # Update the relevant row
            rows[0]['theme'] = theme_name

            # Write all rows back to the CSV file
            with open(filename, mode='w', newline='') as file:
                dict_writer = csv.DictWriter(file, fieldnames=fieldnames)
                dict_writer.writeheader()
                dict_writer.writerows(rows)

    def get_theme(self):
        """Gets currently selected theme from settings.csv file.

        Returns:
            str: name of light theme or name of dark theme
        """    
        file_name = "settings.csv"

        with open(file_name, mode='r') as file:
            reader = csv.DictReader(file)
            settings = next(reader)
            if settings['theme'] == LIGHT_THEME:
                return LIGHT_THEME
            elif settings['theme'] == DARK_THEME:
                return DARK_THEME
            else:
                return LIGHT_THEME  

    def exit_fullscreen(self, event=None):
        """Exits fullscreen mode.
        """
        self.attributes('-fullscreen', False)

    def set_icon(self, path):
        """Sets the window icon using Pillow.
        """
        img = Image.open(path)
        photo = ImageTk.PhotoImage(img)
        self.iconphoto(False, photo)          

    def show_frame(self, page):
        """Shows frame for the given page name.

        Args:
            page(class): class of the page to be shown
        """
        frame = self.frames[page]
        frame.tkraise()

    def wait_for_process(self, process, callback):
        """Starts a process in a new thread and calls a callback function when the process is done.

        Args:
            process (function): function to be called
            callback (function): function to be called when process is done
        """
        t = threading.Thread(target=self.run_process, args=(process, callback))
        t.daemon = True
        t.start()

    def run_process(self, process, callback):
        """Runs a process and calls a callback function when the process is done.

        Args:
            process (function): function to be called
            callback (function): function to be called when process is done
        """
        process()
        self.process_done = True
        self.after(100, callback)

    def change_save_path(self):
        """Asks the user to select a folder to save the files. Changes settings.csv file accordingly.
        """
        new_path = filedialog.askdirectory(title="Select Folder to Save Files")
        if new_path:

            # change in settings.csv file
            filename = "settings.csv"
            fieldnames = ['file path', 'theme']

            # Read all rows from the settings.csv file
            with open(filename, mode='r', newline='') as file:
                dict_reader = csv.DictReader(file)
                rows = list(dict_reader)

            # Update the relevant row
            rows[0]['file path'] = new_path

            # Write all rows back to the CSV file
            with open(filename, mode='w', newline='') as file:
                dict_writer = csv.DictWriter(file, fieldnames=fieldnames)
                dict_writer.writeheader()
                dict_writer.writerows(rows)

            self.save_path = new_path

            messagebox.showinfo("Speicherort geändert", f"Neuer Speicherort: {self.save_path}")

    def on_closing(self):
        """Asks for confirmation before closing the program.
        """
        if messagebox.askyesno(title="Quit", message="Möchten Sie wirklich das Programm beenden?"):
            self.destroy()

    def get_images_in_path(self, directory, image_extensions=[".png", ".jpg", ".jpeg", ".gif", ".bmp"]):
        """Gets a list of image files in the specified directory.

        Args:
        directory (str): The path to the directory to check.
        image_extensions (list): List of image file extensions to check for.

        Returns:
        list: List of image file paths if any image files are found, False otherwise.
        """
        if not os.path.exists(directory):
            return False

        image_files = [os.path.join(directory, file) for file in os.listdir(directory) if any(file.lower().endswith(ext) for ext in image_extensions)]
        return image_files if image_files else False

class CalibrationPage(ttk.Frame):

    def __init__(self, parent, calibration_funcs):
        """Creates Page for calibrating the audiometer.

        Args:
            parent (App): parent application
            calibration_funcs (list function): list of function(s) for calibration in this order: start, next, repeat, stop, set_level
        """
        super().__init__(parent)
        self.parent = parent
        self.cal_start = calibration_funcs[0]
        self.cal_next = calibration_funcs[1]
        self.cal_repeat = calibration_funcs[2]
        self.cal_stop = calibration_funcs[3]
        self.cal_setlevel = calibration_funcs[4]
        self.create_widgets()
        self.finished = False

    def create_widgets(self):
        """Creates the widgets for the page.
        """
        button_width = 25 

        self.intro = ttk.Label(self, text=text_calibration, font=(FONT_FAMILY, SUBHEADER_SIZE))
        self.intro.pack(padx=10, pady=10)

        self.level_label = ttk.Label(self, text="Wert in dBHL, bei dem kalibriert werden soll:", font=(FONT_FAMILY, SUBHEADER_SIZE))
        self.level_label.pack(padx=10, pady=10)

        self.level_entry_var = tk.StringVar()
        self.level_entry_var.set("10")
        self.level_entry = ttk.Entry(self,width=button_width-10, textvariable=self.level_entry_var)
        self.level_entry.pack(padx=10, pady=10)

        self.start_button = ttk.Button(self, 
                                      text="Kalibrierung starten", 
                                      command=self.start_calibration, 
                                      width=button_width)
        self.start_button.pack(padx=10, pady=10)

        self.next_button = ttk.Button(self, 
                                      text="Nächste Frequenz", 
                                      command=self.next_frequency, 
                                      width=button_width,
                                      state=tk.DISABLED)
        self.next_button.pack(padx=10, pady=10)

        self.repeat_button = ttk.Button(self, 
                                         text="Erneut wiedergeben", 
                                         command=self.repeat_frequency, 
                                         width=button_width,
                                         state=tk.DISABLED)
        self.repeat_button.pack(padx=10, pady=10)

        self.stop_button = ttk.Button(self, 
                                         text="Wiedergabe stoppen", 
                                         command=self.stop_playing, 
                                         width=button_width,
                                         state=tk.DISABLED)
        self.stop_button.pack(padx=10, pady=10)

        self.back_button = ttk.Button(self, 
                                         text="Zurück zum Hauptmenü", 
                                         command=lambda: self.parent.show_frame(MainMenu), 
                                         width=button_width) # TODO Kalibrierung resetten, damit man sie dann wieder von vorne anfangen kann
        self.back_button.pack(padx=10, pady=20)

        self.spacer_frame = tk.Frame(self, width=20, height=80)
        self.spacer_frame.pack()

        self.current_freq_var = tk.StringVar(value="Aktuelle Frequenz:")
        self.current_freq = ttk.Label(self, textvariable=self.current_freq_var, font=(FONT_FAMILY, SUBHEADER_SIZE))
        self.current_freq.pack(padx=10, pady=10)

        self.level_expected_var = tk.StringVar(value="Schalldruckpegel (soll):")
        self.level_expected_label = ttk.Label(self, textvariable=self.level_expected_var, font=(FONT_FAMILY, SUBHEADER_SIZE))
        self.level_expected_label.pack(padx=10, pady=10)

        self.level_measured_label = ttk.Label(self, text="Gemessener Schalldruckpegel in dB:", font=(FONT_FAMILY, SUBHEADER_SIZE))
        self.level_measured_label.pack(padx=10, pady=10)
        self.level_measured_var = tk.StringVar()
        self.level_measured_entry = ttk.Entry(self, width=button_width-10, 
                                              font=(FONT_FAMILY, SUBHEADER_SIZE), state=tk.DISABLED,
                                              textvariable=self.level_measured_var)
        self.level_measured_entry.pack(padx=10, pady=10)

        for widget in self.winfo_children():
            widget.pack_configure(anchor='center')

    def start_calibration(self):
        """Starts the calibration process and change state of buttons.
        """
        try:
            current_freq, current_spl = self.cal_start(float(self.level_entry_var.get()))
        except:
            messagebox.showwarning("Warnung", 'Bitte geben Sie eine Zahl ein.')
            return

        self.start_button.config(state=tk.DISABLED)
        self.next_button.config(state=tk.NORMAL)
        self.repeat_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.NORMAL)
        self.level_measured_entry.config(state=tk.NORMAL)

        self.current_freq_var.set("Aktuelle Frequenz: " + str(current_freq) + " Hz")
        self.level_expected_var.set("Schalldruckpegel (soll): " + str(current_spl) + " dB") 


    def next_frequency(self):
        """Sets previously entered level, then get next frequency and play it.
        """
        try:
            if self.level_measured_var.get() != "":
                self.cal_setlevel(float(self.level_measured_var.get()))
            else:
                messagebox.showwarning("Warnung", 'Bitte geben Sie bei "gemessener Schalldruckpegel" eine Zahl ein.')
                return    

        except ValueError:
            messagebox.showwarning("Warnung", 'Bitte geben Sie bei "gemessener Schalldruck" eine Zahl ein.')
            return

        self.level_measured_var.set("")
        more_freqs, current_freq, current_spl = self.cal_next()

        # Change Button when last frequency
        if not more_freqs:
            # Grey out all buttons when finished
            if self.finished:
                self.next_button.config(state=tk.DISABLED)
                self.repeat_button.config(state=tk.DISABLED)
                self.stop_button.config(state=tk.DISABLED)
                self.level_measured_entry.config(state=tk.DISABLED)
                messagebox.showwarning("Kalibrierung abgeschlossen.", "Die Kalibrierung wurde erfolgreich abgeschlossen. Datei gespeichert als calibration.csv")
                return

            self.next_button.config(text="Kalibrierung abschließen")
            self.finished = True

        self.current_freq_var.set("Aktuelle Frequenz: " + str(current_freq) + " Hz")
        self.level_expected_var.set("Schalldruckpegel (soll): " + str(current_spl) + " dB")    

    def repeat_frequency(self):
        """Replays the same frequency."""

        self.cal_repeat()

    def stop_playing(self):
        """Stops playing audio."""

        self.cal_stop()