listeningpy.gui.gui

  1"""
  2This module contains the GUI classes for the listeningpy package.
  3"""
  4import customtkinter as ctk
  5import time
  6import logging
  7from typing import Callable
  8from numpy import ndarray
  9# logging.basicConfig(level=logging.INFO)
 10import configparser
 11
 12import sys
 13from listeningpy.stimuli import play_sound
 14from listeningpy.processing import straight
 15from listeningpy.config import person_identifiers
 16
 17class PlayButton(ctk.CTkButton):
 18    '''Customized customtkinter.CTkButton
 19    Attributes
 20    ----------
 21    parent
 22        parent customtkinter widget    
 23
 24    Methods
 25    -------
 26    reset_count()
 27        Resets the click counter variable to 0.
 28    '''
 29    def __init__(self, parent, *args, **kwargs):
 30        ctk.CTkButton.__init__(self, parent, *args, **kwargs)
 31        self.click_count = 0
 32    
 33    def reset_count(self):
 34        self.click_count = 0
 35
 36class InitFrame(ctk.CTkFrame):
 37    def __init__(self, master, test_frame, cfg_file=None, *args, **kwargs):
 38        ctk.CTkFrame.__init__(self, master, *args, **kwargs)
 39        self.test_frame = test_frame
 40        self.first_name = str
 41        self.second_name = str
 42        self.date_of_birth = str
 43        self.gender = str
 44        self.hear_impaired = bool
 45        self.first_name_label = ctk.CTkLabel(self, text='First name:')
 46        self.second_name_label = ctk.CTkLabel(self, text='Second name:')
 47        self.date_of_birth_label = ctk.CTkLabel(self, text='Date of birth:')
 48        self.gender_label = ctk.CTkLabel(self, text='Gender:')
 49        self.hear_impaired_label = ctk.CTkLabel(self, text='Hearing impaired:')
 50
 51
 52
 53        self.first_name_entry = ctk.CTkEntry(self)
 54        self.second_name_entry = ctk.CTkEntry(self)
 55        
 56        self.date_of_birth_frame = ctk.CTkFrame(self)
 57        self.date_of_birth_day_entry = ctk.CTkEntry(
 58            self.date_of_birth_frame,
 59            width=35,
 60            placeholder_text='DD'
 61            )
 62        self.label_slash = ctk.CTkLabel(self.date_of_birth_frame, text='/')
 63        self.date_of_birth_month_entry = ctk.CTkEntry(
 64            self.date_of_birth_frame,
 65            width=35,
 66            placeholder_text='MM'
 67            )
 68        self.label_slash2 = ctk.CTkLabel(self.date_of_birth_frame, text='/')
 69        self.date_of_birth_year_entry = ctk.CTkEntry(
 70            self.date_of_birth_frame,
 71            width=50,
 72            placeholder_text='YYYY'
 73            )
 74
 75        self.gender_menu = ctk.CTkComboBox(self, 
 76            values=['Man', 'Woman', 'Other']
 77            )
 78        
 79        self.hear_impaired_toggle = ctk.CTkSwitch(
 80            self,
 81            text='', 
 82            onvalue=True, 
 83            offvalue=False)
 84
 85        if cfg_file is not None:
 86            self.set_identifiers(cfg_file)
 87
 88        self.start_button = ctk.CTkButton(self, text='Start test', command=self.button_clicked)
 89
 90        self.first_name_label.grid(column=0, row=1,
 91            padx=10,
 92            pady=5,
 93            sticky='e')
 94        self.second_name_label.grid(column=0, row=2,
 95            padx=10,
 96            pady=5,
 97            sticky='e')
 98        self.date_of_birth_label.grid(column=0, row=3,
 99            padx=10,
100            pady=5,
101            sticky='e')
102        self.gender_label.grid(column=0, row=4,
103            padx=10,
104            pady=5,
105            sticky='e')
106        self.hear_impaired_label.grid(column=0, row=5,
107            padx=10,
108            pady=5,
109            sticky='e')
110        
111        self.first_name_entry.grid(column=1, row=1,
112            padx=10,
113            pady=5)
114        self.second_name_entry.grid(column=1, row=2,
115            padx=10,
116            pady=5)
117        self.date_of_birth_frame.grid(column=1, row=3)
118        self.date_of_birth_day_entry.grid(column=0, row=0,
119            padx=1,
120            pady=5)
121        self.label_slash.grid(column=1, row=0,
122            padx=1,
123            pady=5)
124        self.date_of_birth_month_entry.grid(column=2, row=0,
125            padx=1,
126            pady=5)
127        self.label_slash2.grid(column=3, row=0,
128            padx=2,
129            pady=5)
130        self.date_of_birth_year_entry.grid(column=4, row=0,
131            padx=1,
132            pady=5)
133
134        self.gender_menu.grid(column=1, row=4,
135            padx=10,
136            pady=5)
137        self.hear_impaired_toggle.grid(column=1, row=5,
138            padx=10,
139            pady=8, sticky='w')
140        self.start_button.grid(column=1, row=6,
141            padx=10,
142            pady=5)
143    
144    def set_identifiers(self, cfg_file):
145        identifiers = person_identifiers(cfg_file)
146        keys = identifiers.keys()
147        if 'first_name' in keys:
148                self.first_name = identifiers['first_name']
149                self.first_name_entry.insert(0, self.first_name)
150        if 'second_name' in keys:
151            self.second_name = identifiers['second_name']
152            self.second_name_entry.insert(0, self.second_name)
153        if 'date_of_birth' in keys:
154            self.date_of_birth = identifiers['date_of_birth']
155            self.date_of_birth_day_entry.insert(0, self.date_of_birth[:2])
156            self.date_of_birth_month_entry.insert(0, self.date_of_birth[3:5])
157            self.date_of_birth_year_entry.insert(0, self.date_of_birth[6:10])
158        if 'gender' in keys:
159            self.gender = identifiers['gender']
160            self.gender_menu.set(self.gender)
161        if 'hear_impaired' in keys:
162            print(identifiers['hear_impaired'])
163            self.hear_impaired = identifiers['hear_impaired'].lower() == "true"
164            print(self.hear_impaired)
165            if self.hear_impaired:
166                self.hear_impaired_toggle.select()
167
168    def button_clicked(self):
169        self.first_name = self.first_name_entry.get()
170        self.second_name = self.second_name_entry.get()
171        self.date_of_birth = f'{self.date_of_birth_day_entry.get()}/{self.date_of_birth_month_entry.get()}/{self.date_of_birth_year_entry.get()}'
172        self.gender = self.gender_menu.get()
173        self.hear_impaired = self.hear_impaired_toggle.get()
174        self.master.switch_frame(self.test_frame)
175
176class InitFrameAdaptive(ctk.CTkFrame):
177    """A class representing the initial frame for an adaptive test.
178
179    This frame allows the user to input the participant identifier and the sentence set for the test.
180
181    Parameters
182    ----------
183    master : cTK.Widget
184        The master widget.
185    test_frame : _type_
186        The frame representing the test.
187
188    Attributes
189    ----------
190    test_frame : _type_
191        The frame representing the test.
192    timestamp : str
193        The current timestamp in the format "yy-mm-dd_HH-MM".
194    participant : str
195        The participant identifier.
196    sentence_set : str
197        The sentence set for the test.
198    participant_label : ctk.CTkLabel
199        The label for the participant identifier.
200    sentence_set_label : ctk.CTkLabel
201        The label for the sentence set.
202    participant_entry : ctk.CTkEntry
203        The entry field for the participant identifier.
204    sentence_set_entry : ctk.CTkEntry
205        The entry field for the sentence set.
206    start_button : ctk.CTkButton
207        The button to start the test.
208
209    Methods
210    -------
211    button_clicked()
212        Event handler for the button click event. Sets the participant identifier and sentence set,
213        loads the sentences for the test, and switches to the test frame.
214    """
215    def __init__(self, master, test_frame, *args, **kwargs):
216        ctk.CTkFrame.__init__(self, master, *args, **kwargs)
217        self.test_frame : ctk.CTkFrame = test_frame
218        self.timestamp = time.strftime("%y-%m-%d_%H-%M")
219        self.participant = str
220        self.sentence_set = str
221        self.participant_label = ctk.CTkLabel(self, text='Participant identifier:')
222        self.sentence_set_label = ctk.CTkLabel(self, text='Sentence set:')
223        self.participant_entry = ctk.CTkEntry(self)
224        self.sentence_set_entry = ctk.CTkEntry(self)
225        self.start_button = ctk.CTkButton(
226            self, 
227            text='Start test', 
228            command=self.button_clicked)
229        
230        self.participant_label.grid(column=0, row=1,
231            padx=10,
232            pady=5,
233            sticky='e')
234        self.sentence_set_label.grid(column=0, row=2,
235            padx=10,
236            pady=5,
237            sticky='e')
238        self.participant_entry.grid(column=1, row=1,
239            padx=10,
240            pady=5)
241        self.sentence_set_entry.grid(column=1, row=2,
242            padx=10,
243            pady=5)
244        self.start_button.grid(column=1, row=3,
245            padx=10,
246            pady=5)
247        
248    def button_clicked(self):
249        """Handles the button click event.
250
251        This method retrieves the participant and sentence set information from the GUI,
252        sets the ID of the sentence set, loads the sentences, and switches to the test frame.
253
254        """
255        self.participant = self.participant_entry.get()
256        self.sentence_set = self.sentence_set_entry.get()
257        self.test_frame.set_id = self.sentence_set
258        self.test_frame.load_sentences()
259        self.master.switch_frame(self.test_frame)
260        
261class IntermediateFrameAdaptive(ctk.CTkFrame):
262    """A custom frame for intermediate adaptive testing.
263
264    This frame is used to display the intermediate adaptive testing interface.
265    It contains widgets for entering the next sentence set, starting the test,
266    and ending the test.
267
268    Parameters
269    ----------
270    master : tk.Tk
271        The master widget.
272    test_frame : TestFrame
273        The test frame to switch to after starting the test.
274    *args : tuple
275        Additional positional arguments.
276    **kwargs : dict
277        Additional keyword arguments.
278    """
279    def __init__(self, master, test_frame, *args, **kwargs):
280        ctk.CTkFrame.__init__(self, master, *args, **kwargs)
281        self.test_frame = test_frame
282        self.sentence_set = str
283        self.sentence_set_label = ctk.CTkLabel(self, text='Next sentence set:')
284        self.sentence_set_entry = ctk.CTkEntry(self)
285        self.start_button = ctk.CTkButton(
286            self, 
287            text='Start test', 
288            command=self.button_clicked)
289        self.end_button = ctk.CTkButton(
290            self, 
291            text='End test', 
292            command=self.master.destroy)
293        
294        self.sentence_set_label.grid(column=0, row=2,
295            padx=10,
296            pady=5,
297            sticky='e')
298        self.sentence_set_entry.grid(column=1, row=2,
299            padx=10,
300            pady=5)
301        self.start_button.grid(column=1, row=3,
302            padx=10,
303            pady=5)
304        self.end_button.grid(column=1, row=4,
305            padx=10,
306            pady=5,
307            )
308        
309    def button_clicked(self):
310        """Callback function for the start button click event.
311
312        This function is called when the start button is clicked. It retrieves
313        the sentence set entered by the user, sets it in the test frame, loads
314        the sentences for the test, and switches to the test frame.
315        """
316        self.sentence_set = self.sentence_set_entry.get()
317        self.test_frame.set_id = self.sentence_set
318        self.test_frame.load_sentences()
319        self.master.switch_frame(self.test_frame)
320
321def count_add(button: PlayButton):
322    '''Adds 1 to click counter attribute of a PlayButton
323
324    Parameters
325    ----------
326    button : PlayButton
327    '''
328    button.click_count += 1
329
330def first_clicked(button: ctk.CTkButton):
331    '''Checks whether the button is clicked for the first time. In case
332    it is, the current time is stored for future duration evaluation.
333
334    Parameters
335    ----------
336    button : ctk.CTkButton
337    '''
338    if not hasattr(button, 'time') or button.time == 0:
339        button.time = time.time()
340        logging.info("clicked!")
341
342def stopwatch(
343        button_start: PlayButton,
344        button_end: ctk.CTkButton
345        ) -> float:
346    '''Calculates the time needed for the completion of current set.
347
348    Parameters
349    ----------
350    button_start : PlayButton
351        first button clicked
352    button_end : ctk.CTkButton
353        last button clicked ('Next')
354    Returns
355    -------
356    t : float
357        time between first and last click
358    '''
359    t = button_end.time-button_start.time
360    button_start.time = 0
361    button_end.time = 0
362    return t
363
364def play_click(
365        stimuli_path: str,
366        button: PlayButton,
367        next_buttons: list[ctk.CTkButton, ctk.CTkRadioButton],
368        processing_func: Callable[[ndarray, int], ndarray]=straight,
369        **kwargs
370        ) -> None:
371    '''Defines actions for playback buttons.
372
373    - adding 1 to button.click_count
374    - playing stimuli
375    - enables next button
376
377    Parameters
378    ----------
379    stimuli_path : str
380        path to stimuli
381    button : PlayButton
382        button just clicked (for counter)
383    next_buttons : list[ctk.CTkButton, ctk.CTkRadioButton]
384        list of buttons to be enabled after click
385    '''
386    count_add(button)
387    first_clicked(button)
388    logging.info(f"Playing {stimuli_path}")
389    play_sound(path=stimuli_path, processing_func=processing_func, **kwargs)
390    for n in next_buttons:
391        n.configure(state=ctk.NORMAL)
392
393def check_choice(
394        last_played: PlayButton,
395        button_end: ctk.CTkButton
396        ):
397    '''Enables the 'Next' button. Checks whether all stimuli were played and
398    one chosen.
399
400    Parameters
401    ----------
402    last_played : PlayButton
403        last enabled PlayButton
404    button_end : ctk.CTkButton
405        'Next' button
406    '''
407    if last_played.cget("state") == ctk.NORMAL:
408        button_end.configure(state=ctk.NORMAL)