def main(): #Show window lucia.show_window("1d Sound Example.") #Create the player listener = player() #Play a sound on a 1d grid. #Must use 2d playing function in order for the sound to actually pan sound_pool.play_2d("ding.ogg", listener.x, 0, 0, 0, True) while 1: #Allow lucia to update it's internal queues and events lucia.process_events() #Check for key presses if lucia.key_pressed(lucia.K_LEFT): #Move the player 1 step to the left listener.x -= 1 #Update the sound pool with the new player position sound_pool.update_listener_1d(listener.x) elif lucia.key_pressed(lucia.K_RIGHT): #Move the player 1 step to the right listener.x += 1 #Update the sound pool with the new player position sound_pool.update_listener_1d(listener.x) elif lucia.key_pressed(lucia.K_c): #Output x coordinate lucia.output.output(str(listener.x)) elif lucia.key_pressed(lucia.K_ESCAPE): #Exit lucia.quit() sys.exit() #Sleep for 2 milliseconds lucia.pygame.time.wait(2)
def main(): #Show window lucia.show_window("2d Sound Example.") #Create the player listener = player() #Play a sound on a 2d grid. sound_pool.play_2d("ding.ogg", listener.x, listener.y, 0, 0, True) while 1: #Allow lucia to update it's internal queues and events lucia.process_events() #Check for key presses if lucia.key_pressed(lucia.K_LEFT): #Move the player 1 step to the left move_object(listener, 3) elif lucia.key_pressed(lucia.K_RIGHT): #Move the player 1 step to the right move_object(listener, 1) elif lucia.key_pressed(lucia.K_UP): #Move the player one step forward move_object(listener, 0) elif lucia.key_pressed(lucia.K_DOWN): #Move the player one step backwards move_object(listener, 2) elif lucia.key_pressed(lucia.K_c): #Output coordinates lucia.output.output(str(listener.x) + ", " + str(listener.y)) elif lucia.key_pressed(lucia.K_ESCAPE): #Exit lucia.quit() sys.exit() #Sleep for 2 milliseconds lucia.pygame.time.wait(2)
def run(self, intro, isfile=False): try: self._running = True self.__play__("open") if self._title: lucia.output.speak(self._title) if not isfile: lucia.output.speak(intro, False) else: intro = self.__load__(intro) intro.volume = self._volume print(intro.volume) intro.play() while self._running: time.sleep(0.005) # Be kind to processors lucia.process_events() if lucia.key_pressed(lucia.K_UP): self.__change_position__(1, intro, isfile) elif lucia.key_pressed(lucia.K_DOWN): self.__change_position__(-1, intro, isfile) elif lucia.key_pressed(lucia.K_RETURN): self.__play__("enter") self._running = False return True print("end") except Exception as e: lucia.logger.exception(e) else: return False
def main(): #Create a game window lucia.show_window("Timer Example.") #Create a timer countdown_timer = lucia.utils.timer.Timer() #Loop for 2 seconds while countdown_timer.elapsed <= 2000: #Allow lucia to update it's internal queues and events lucia.process_events() #Sleep for 2 milliseconds lucia.pygame.time.wait(2) #Output a message lucia.output.output("Now you see me...") #Restart the timer before continuing to loop countdown_timer.restart() #Loop for another 2 seconds while countdown_timer.elapsed <= 2000: #Allow lucia to update it's internal queues and events lucia.process_events() #Sleep for 2 milliseconds lucia.pygame.time.wait(2) #Output another message lucia.output.output("Now you don't!") lucia.quit() sys.exit()
def run(self, intro, isfile=False): # Overrides the run function in menu try: self._running = True self.__play__("open") if self._title: lucia.output.speak(self._title) if not isfile: lucia.output.speak(intro, False) else: intro = self.__load__(intro) intro.play() while self._running: time.sleep(0.005) lucia.process_events() if lucia.key_pressed(lucia.K_DOWN) and not self.orientation: self.__change_position__(1) elif lucia.key_pressed(lucia.K_UP) and not self.orientation: self.__change_position__(-1) elif lucia.key_pressed(lucia.K_LEFT) and self.orientation: self.__change_position__(-1) elif lucia.key_pressed(lucia.K_RIGHT) and self.orientation: self.__change_position__(1) elif lucia.key_pressed(lucia.K_RETURN): return self.__return_selection__() except Exception: self._running = False lucia.logger.exception(e)
def MainLoop(): global x, oldX, y, oldY, direction, oldDirection timer = utils.Timer( ) # Prevents the user from walking faster than the sound can play. You're not the Flash. WALK_SPEED = 300 # milliseconds timer.elapsed = WALK_SPEED # So the user can walk straight away xAxis, yAxis = (0, 0) while True: time.sleep(0.005) # Be kind to processors lucia.process_events() # Set the movement coordinate changes if lucia.key_down(lucia.K_UP): yAxis = 1 if lucia.key_down(lucia.K_DOWN): yAxis = -1 if lucia.key_up(lucia.K_UP) and lucia.key_up(lucia.K_DOWN): yAxis = 0 if lucia.key_down(lucia.K_RIGHT): xAxis = 1 if lucia.key_down(lucia.K_LEFT): xAxis = -1 if lucia.key_up(lucia.K_RIGHT) and lucia.key_up(lucia.K_LEFT): xAxis = 0 if (not xAxis == 0 or not yAxis == 0) and timer.elapsed >= WALK_SPEED: timer.restart() # Set the direction if xAxis == 0 and yAxis == 1: direction = 90 elif xAxis == 1 and yAxis == 1: direction = 45 elif xAxis == 1 and yAxis == 0: direction = 0 elif xAxis == 1 and yAxis == -1: direction = 315 elif xAxis == 0 and yAxis == -1: direction = 270 elif xAxis == -1 and yAxis == -1: direction = 225 elif xAxis == -1 and yAxis == 0: direction = 180 elif xAxis == -1 and yAxis == 1: direction = 135 # set new coordinates x, y = (x + xAxis, y + yAxis) # Update the listener pool.update_listener_3d(x, y, 0, direction) if not direction == oldDirection: squeak.play() oldDirection = direction if (not oldX == x) or (not oldY == y): step.play() oldX, oldY = (x, y) if lucia.key_pressed(lucia.K_q): break elif lucia.key_pressed(lucia.K_c): lucia.output.speak( f"you are at x: {x}, y: {y}, facing {textDirections[direction]}" ) elif lucia.key_pressed(lucia.K_z): x = 0 y = 0 direction = 90 pool.update_listener_3d(x, y, 0, direction)
def play_wait(self): if not self.is_active: return False self.handle.looping = False #return bool(self.handle.play_blocking()) # We can't block, we need to make a hack, to keep the ui responsive result = bool(self.handle.play()) while self.handle.is_playing: lucia.process_events() return result
def main(): #Show window lucia.show_window("Simple Sound Example.") #Play a stationary sound #Stationary means that the sound cannot move, regardless of what the player does #The first parameter is the filename, while the second one dictates whether the sound can loop or not sound_pool.play_stationary("ding.ogg", True) while 1: #Allow lucia to update it's internal queues and events lucia.process_events() #No extra code is needed to handle when the user presses alt f4, Lucia does this on it's own. #Sleep for 2 milliseconds lucia.pygame.time.wait(2)
def run(self, message, callback=None): """Retrieves user input Parameters: message (str): The message to be shown as the input pops up callback (callable): What will be called every iteration of the input loop. The input will pass in itself as the only parameter to the callback Return Value: self.current_text (str): What the user entered """ lucia.output.output(message, True) self.clear() while not self.is_at_character_limit: events = lucia.process_events() if callable(callback): callback(self) for event in events: if event.type == lucia.KEYDOWN: if self.repeating_keys and event.key not in self._key_times: self._key_times[event.key] = [ self.key_repeat_timer.elapsed + self.initial_key_repeating_time, event.unicode ] if self.can_exit and event.key == lucia.K_RETURN: return self.current_text elif self.can_escape and event.key == lucia.K_ESCAPE: return "" elif event.key == lucia.K_BACKSPACE: self.remove_character() elif event.key == lucia.K_TAB: lucia.output.output(self.current_string, True) elif event.key == lucia.K_LEFT: self.move_in_string(-1) self.speak_character(self.get_character()) elif event.key == lucia.K_RIGHT: self.move_in_string(1) self.speak_character(self.get_character()) elif event.key == lucia.K_HOME: self.snap_to_top() elif event.key == lucia.K_END: self.snap_to_bottom() elif event.key == lucia.K_F2: lucia.output.output( "Character repeat on" ) if self.toggle_character_repetition( ) else lucia.output.output("Character repeat off") else: if event.unicode in self.whitelisted_characters: self.insert_character(event.unicode) elif event.type == lucia.KEYUP: if event.key in self._key_times: del self._key_times[event.key] for key in self._key_times: if self.key_repeat_timer.elapsed >= self._key_times[key][0]: self._key_times[key][0] += self.repeating_increment lucia.pygame.event.post( lucia.pygame.event.Event( lucia.KEYDOWN, key=key, unicode=self._key_times[key][1])) lucia.pygame.time.wait(2) return self.current_text
def main(): #Show window lucia.show_window("Speaking Example.") while 1: #Allow lucia to update it's internal queues and events lucia.process_events() #Check for key presses if lucia.key_pressed(lucia.K_SPACE): lucia.output.output("Hello, world!") if lucia.key_pressed(lucia.K_RETURN): lucia.output.output("Good bye, world!") #Account for slower screen readers lucia.pygame.time.wait(1500) lucia.quit() sys.exit() #Sleep for 2 milliseconds lucia.pygame.time.wait(2)
def main(): #Show window lucia.show_window("Keyboard Example.") while 1: #Allow lucia to update it's internal queues and events lucia.process_events() #Check for key presses #Typically this should be done in a separate function, but we will keep this as simple as possible if lucia.key_pressed(lucia.K_SPACE): print("You pressed space!") sys.exit() #Check for key holds if lucia.key_down(lucia.K_RETURN): print("You held enter!") lucia.quit() sys.exit() #Sleep for 2 milliseconds lucia.pygame.time.wait(2)
def run(self, intro="", isfile=False): """ Displayes the menu and waits for a selection This function blocks until the menu is closed, either by selecting an item or pressing escape. Available controls are up/down arrows, enter, and escape. Wrapping is not supported. args: intro (str, optional): Some brief instructions spoken after the menu title. isfile (bool, optional): Set to True if the intro is the name of an audio file that contains the intro returns: Either the item name, its value, or -1 if escape is allowed. """ try: self._running = True self.__play__("open") if self._title: lucia.output.speak(self._title) if intro: if not isfile: lucia.output.speak(intro, False) else: intro = self.__load__(intro) intro.play() while self._running: time.sleep(0.005) # Be kind to processors lucia.process_events() if callable(self._callback): self._callback(self) if lucia.key_pressed(lucia.K_ESCAPE) and self.exit_on_escape: self._running = False self.__play__(self._sounds["cancel"]) return "-1" elif lucia.key_pressed(lucia.K_DOWN): self.__change_position__(1) elif lucia.key_pressed(lucia.K_UP): self.__change_position__(-1) elif lucia.key_pressed(lucia.K_LEFT) and callable( self._items[self._item_position].slider_function): self._items[self._item_position].slider_function(self, -1) elif lucia.key_pressed(lucia.K_RIGHT) and callable( self._items[self._item_position].slider_function): self._items[self._item_position].slider_function(self, 1) elif lucia.key_pressed(lucia.K_SPACE) and self._items[ self._item_position].can_be_toggled: self.__change_toggle__() elif (lucia.key_pressed(lucia.K_LSHIFT) or lucia.key_pressed(lucia.K_RSHIFT) ) and self._items[self._item_position].enter_value: self.__get_input__() elif lucia.key_pressed(lucia.K_RETURN): self._running = False return self.__return_selection__() except Exception as e: lucia.logger.exception(e) finally: self._running = False
def MainLoop(): global x, y, width, height timer = utils.Timer( ) # Prevents the user from walking faster than the sound can play. You're not the Flash. WALK_SPEED = 300 # milliseconds timer.elapsed = WALK_SPEED # So the user can walk straight away xAxis, yAxis = (0, 0) # Define the shapes # Each vertice followed by a fill value (True fills the shape in, False plots only the outline) sky = utils.Rectangle(0, 29, 29, 19, True) # Top left corner to bottom left corner ground = utils.Rectangle(0, 18, 29, 0, True) sun = utils.Circle(4, 25, 3, True) # The center point followed by the radius roof = utils.Triangle(11, 22, 25, 22, 18, 27, True) # The three corner vertices of the triangle house = utils.Rectangle(13, 21, 23, 13, True) # Draw each shape one by one for v in sky: field[v[0]][v[1]] = "blue" for v in ground: field[v[0]][v[1]] = "green" for v in sun: field[v[0]][v[1]] = "yellow" for v in roof: field[v[0]][v[1]] = "red" for v in house: field[v[0]][v[1]] = "brown" # Main action loop while True: time.sleep(0.005) # Be kind to processors lucia.process_events() # Set the movement coordinate changes if lucia.key_down(lucia.K_UP): yAxis = 1 if lucia.key_down(lucia.K_DOWN): yAxis = -1 if lucia.key_up(lucia.K_UP) and lucia.key_up(lucia.K_DOWN): yAxis = 0 if lucia.key_down(lucia.K_RIGHT): xAxis = 1 if lucia.key_down(lucia.K_LEFT): xAxis = -1 if lucia.key_up(lucia.K_RIGHT) and lucia.key_up(lucia.K_LEFT): xAxis = 0 # Only do something if the keys are pressed and slow down any change based on the speed of movement if (not xAxis == 0 or not yAxis == 0) and timer.elapsed >= WALK_SPEED: timer.restart() # set new coordinates if x + xAxis >= 0 and y + yAxis >= 0 and x + xAxis < width and y + yAxis < height: # Check to be sure the coordinates are within the field x, y = (x + xAxis, y + yAxis) lucia.output.speak(str(field[x][y])) else: lucia.output.speak("bump") # Some other function keys (These are not restricted by the walk speed) if lucia.key_pressed(lucia.K_q): # Quit the program break elif lucia.key_pressed(lucia.K_z): # Speak the coordinates of the user lucia.output.speak(f"you are at x: {x}, y: {y}")
def loop(self): while 1: time.sleep(0.005) try: lucia.process_events() if callable(self.callback): self.callback() if lucia.key_pressed(lucia.K_RETURN): if self.items[self.itempos].can_return: if self.entersound != "": source = self.pool.play_stationary(self.entersound) list_values = [] if self.items[self.itempos].event == CANCELEVENT: if callable( self.items[self.itempos].item_function): self.items[self.itempos].item_function() return list_values #returns results as a list of dictionaries. The currently focused item returns as the first item in the list for x in self.items: if x.name != self.items[self.itempos].name: list_values.append({ "name": x.name, "value": x.value, "toggle_value": x.toggle_value }) list_values.insert( 0, { "name": self.items[self.itempos].name, "value": self.items[self.itempos].value, "toggle_value": self.items[self.itempos].toggle_value, }, ) if callable(self.items[self.itempos].item_function): self.items[self.itempos].item_function() else: return list_values elif lucia.key_pressed(lucia.K_UP): if self.itempos > 0: self.itempos -= 1 if self.clicksound != "": clicksound = self.pool.play_stationary( self.clicksound) if callable(self.on_index_change): self.on_index_change() if callable(self.items[self.itempos].on_focus): self.items[self.itempos].on_focus(self) if (self.items[self.itempos].has_value == False and self.items[self.itempos].can_be_toggled == False): lucia.output.speak(self.items[self.itempos].name) elif (self.items[self.itempos].has_value and self.items[self.itempos].can_be_toggled == False): lucia.output.speak( self.items[self.itempos].name + ": " + str(self.items[self.itempos].value) + ". Press left shift or right shift to change this item's value" ) elif (self.items[self.itempos].has_value == False and self.items[self.itempos].can_be_toggled): if self.items[self.itempos].toggle_value == True: lucia.output.speak( self.items[self.itempos].name + ": " + self.items[self.itempos].on_value + " " + self.items[ self.itempos].toggle_item_message + " " + self.items[self.itempos].off_value) else: lucia.output.speak( self.items[self.itempos].name + ": " + self.items[self.itempos].off_value + " " + self.items[ self.itempos].toggle_item_message + " " + self.items[self.itempos].on_value) elif (self.items[self.itempos].has_value and self.items[self.itempos].can_be_toggled): speakstr = (self.items[self.itempos].name + ". Value: " + str(self.items[self.itempos].value)) if self.items[self.itempos].toggle_value == True: speakstr += ". Switch: " + self.items[ self.itempos].on_value else: speakstr += ". Switch: " + self.items[ self.itempos].off_value lucia.output.speak( speakstr + ". Press left shift or right shift to change this item's value. " + self.items[self.itempos].toggle_item_message) elif lucia.key_pressed(lucia.K_DOWN): if self.itempos < len(self.items) - 1: self.itempos += 1 if self.clicksound != "": clicksound = self.pool.play_stationary( self.clicksound) if self.items[self.itempos].on_focus != None: self.items[self.itempos].on_focus() if self.on_index_change != None: self.on_index_change() if (self.items[self.itempos].has_value == False and self.items[self.itempos].can_be_toggled == False): lucia.output.speak(self.items[self.itempos].name) elif (self.items[self.itempos].has_value and self.items[self.itempos].can_be_toggled == False): lucia.output.speak( self.items[self.itempos].name + ": " + str(self.items[self.itempos].value) + ". Press left shift or right shift to change this item's value" ) elif (self.items[self.itempos].has_value == False and self.items[self.itempos].can_be_toggled): if self.items[self.itempos].toggle_value == True: lucia.output.speak( self.items[self.itempos].name + ": " + self.items[self.itempos].on_value + " " + self.items[ self.itempos].toggle_item_message + " " + self.items[self.itempos].off_value) else: lucia.output.speak( self.items[self.itempos].name + ": " + self.items[self.itempos].off_value + " " + self.items[ self.itempos].toggle_item_message + " " + self.items[self.itempos].on_value) elif (self.items[self.itempos].has_value and self.items[self.itempos].can_be_toggled): speakstr = (self.items[self.itempos].name + ". Value: " + str(self.items[self.itempos].value)) if self.items[self.itempos].toggle_value == True: speakstr += ". Switch: " + self.items[ self.itempos].on_value else: speakstr += ". Switch: " + self.items[ self.itempos].off_value lucia.output.speak( speakstr + ". Press left shift or right shift to change this item's value. " + self.items[self.itempos].toggle_item_message) elif lucia.key_pressed(lucia.K_SPACE): if self.itempos > -1 and self.itempos < len(self.items): if self.items[self.itempos].can_be_toggled: if self.entersound != "": entersound = self.pool.play_stationary( self.entersound) if self.items[self.itempos].toggle_value == True: lucia.output.speak( self.items[self.itempos].off_value) self.items[self.itempos].toggle_value = False else: lucia.output.speak( self.items[self.itempos].on_value) self.items[self.itempos].toggle_value = True elif lucia.key_down(lucia.K_LSHIFT) or lucia.key_down( lucia.K_RSHIFT): if self.items[self.itempos].has_value == True: self.items[self.itempos].value = getinput( "change value", self.items[self.itempos].name + ". ", value=self.items[self.itempos].value, mode=self.items[self.itempos].value_mode, ) lucia.output.speak("value set to " + str(self.items[self.itempos].value)) if self.entersound != "": entersound = self.pool.play_stationary( self.entersound) except Exception as e: lucia.output.speak(str(e))
def callback_test(menu): print("hello world") menu = lucia.ui.Menu() menu.add_item_tts("Hello") menu.add_item_tts("world") menu.add_item_tts("this") menu.add_item_tts("is") menu.add_item_tts("a") menu.add_item_tts("test") menu.set_callback(callback_test) result = menu.run("Please select something") print(str(result)) username = lucia.ui.VirtualInput("Enter a username") result = username.run() print(f"username: {result}") password = lucia.ui.VirtualInput("Enter a password", True) result = password.run() print(f"password: {result}") while True: lucia.process_events() if lucia.key_pressed(lucia.K_a): lucia.output.output("Hey.") if lucia.key_pressed(lucia.K_q): break lucia.quit()
def run(self, intro="select an option", interrupt=True): """presents this menu to the user. This function blocks until the menu is closed, either by selecting an item or pressing escape. Available controls are up/down arrows, enter, and escape. Wrapping is not supported. args: intro (str, optional): The text that will be spoken when the menu is presented, this will occur at the same time as the open sound. Default is 'select an option' interrupt (bool, optional): Determines if speech is interrupted when it is queued to be spoken. For your sanity, this should always be True. Defaults to True. returns: str if an option was selected, containing the option's internal name. -1 if escape was pressed. """ self.count = 0 self.running = True try: self.music.play() except: pass try: self.open_sound.play() except: pass if intro != "": self.speechMethod.speak(intro, interrupt) while self.running and lucia.running: lucia.process_events() if callable(self.callback): self.callback(self) time.sleep(0.005) if lucia.key_pressed(lucia.K_ESCAPE): try: self.enter_sound.play() except: pass try: self.music.stop() except: # thrown if no music was specified. pass return "-1" if lucia.key_pressed(lucia.K_DOWN): if self.count < len(self.items) - 1: self.count = self.count + 1 try: self.scroll_sound.play() except: pass else: try: self.border_sound.play() except: pass self.speechMethod.speak( list(self.items)[self.count], self.shouldInterrupt) if lucia.key_pressed(lucia.K_UP): if self.count > 0: self.count = self.count - 1 try: self.scroll_sound.play() except: pass else: try: self.border_sound.play() except: pass self.speechMethod.speak( list(self.items)[self.count], self.shouldInterrupt) if lucia.key_pressed(lucia.K_RETURN): try: self.enter_sound.play() except: pass self.running = False try: self.music.stop() except: # thrown if no music was selected pass return self.items[list(self.items)[self.count]]
def run(self): lucia.output.output(self.message) while True: time.sleep(0.001) if callable(self.callback): self.callback(self) if self.input_break: break events = lucia.process_events() for event in events: if event.type == pygame.KEYDOWN: if event.key == lucia.K_UP: self.charindex = 0 self._output_char(self.text, True) elif event.key == lucia.K_DOWN: self.charindex = len(self.text) self._output_char(self.text, True) elif event.key == lucia.K_HOME: self.charindex = 0 self._output_char(self.text[0]) elif event.key == lucia.K_END: self.charindex = len(self.text) lucia.output.speak("Blank") elif event.key == lucia.K_LEFT and len(self.text) > 0: if self.charindex > 0: self.charindex -= 1 elif self.charindex <= 0: self.charindex = 0 self._output_char(self.text[self.charindex]) elif event.key == lucia.K_RIGHT and len(self.text) > 0: if self.charindex < len(self.text): self.charindex += 1 if self.charindex >= len(self.text): self.charindex = len(self.text) #using the default speaking function, to prevent from saying the hidden_message instead of blank when in a password field. lucia.output.speak("blank") elif self.charindex <= len(self.text) - 1: self._output_char(self.text[self.charindex]) else: lucia.output.speak("blank") elif event.key == lucia.K_BACKSPACE: if len(self.text) == 0 or self.charindex <= 0: continue what = self.text[self.charindex - 1] temp = "" if self.charindex < len(self.text): temp = self.text[:self.charindex - 1] + self.text[self.charindex:] elif self.charindex == len(self.text): temp = self.text[:self.charindex - 1] self.text = temp self.charindex -= 1 self._output_char(what) elif event.key == lucia.K_RETURN: return self.text elif event.key == lucia.K_SPACE: if self.charindex < len(self.text): self.text = self.text[:self. charindex] + " " + self.text[ self.charindex:] self.charindex += 1 elif self.charindex == len(self.text): self.text += " " self.charindex += 1 self._output_char(" ") else: try: if event.unicode in self.allowed_characters: if self.charindex < len(self.text): self.text = self.text[:self. charindex] + event.unicode + self.text[ self.charindex:] self.charindex += 1 elif self.charindex == len(self.text): self.text += event.unicode self.charindex += 1 self._output_char(event.unicode) except ValueError: continue
def test_process_events(): if lucia.running == False: lucia.initialize() assert lucia.process_events() is not None
def run(self, intro="", isfile=False): """ Displayes the menu and waits for a selection This function blocks until the menu is closed, either by selecting an item or pressing escape. Available controls are up/down arrows, tab and shift + tab, ctrl + up and down, space and enter, and escape. args: intro (str, optional): Some brief instructions spoken after the menu title. isfile (bool, optional): Set to True if the intro is the name of an audio file that contains the intro returns: The name of a file or directory """ try: self._running = True self.__play__("open") if self._title: lucia.output.speak(self._title) if intro: if not isfile: lucia.output.speak(intro, False) else: intro = self.__load__(intro) intro.play() while self._running: time.sleep(0.005) # Be kind to processors lucia.process_events() if callable(self._callback): self._callback(self) if lucia.key_pressed(lucia.K_ESCAPE) and self.exit_on_escape: self._running = False self.__play__("cancel") return "-1" elif lucia.key_pressed(lucia.K_DOWN): if lucia.key_down(lucia.K_LALT) or lucia.key_down( lucia.K_RALT): self.__forward__() else: self.__change_position__(1) elif lucia.key_pressed(lucia.K_UP): if lucia.key_down(lucia.K_LALT) or lucia.key_down( lucia.K_RALT): self.__back__() else: self.__change_position__(-1) if lucia.key_pressed(lucia.K_TAB): if lucia.key_down(lucia.K_RSHIFT) or lucia.key_down( lucia.K_LSHIFT): self.__change_tab__(-1) else: self.__change_tab__(1) elif lucia.key_pressed(lucia.K_RETURN) or lucia.key_pressed( lucia.K_SPACE): result = self.__return_selection__() if result: self._running = False return result except Exception as e: lucia.logger.exception(e) finally: self._running = False