def handle_event(self, event):
        """ Menu event handler
        
        :param event: menu event
        """
        if not self.visible: return

        if event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD:
            key_events = [
                kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT], kbd_keys[KEY_UP],
                kbd_keys[KEY_DOWN], kbd_keys[KEY_PAGE_UP],
                kbd_keys[KEY_PAGE_DOWN], kbd_keys[KEY_SELECT]
            ]
            if event.keyboard_key not in key_events:
                return

            if not self.is_menu_selected():
                return

            if event.action == pygame.KEYUP:
                self.key_up(event)
            elif event.action == pygame.KEYDOWN:
                self.key_down(event)
        elif event.type == SELECT_EVENT_TYPE:
            if event.source == self:
                return
            self.handle_select_action(event.x, event.y)
        elif event.type in self.mouse_events:
            if not self.bounding_box.collidepoint(event.pos):
                return

            Container.handle_event(self, event)
Exemple #2
0
    def handle_event(self, event):
        """ Menu event handler

        :param event: menu event
        """
        if not self.visible: return

        if event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP:
            key_events = [kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT], kbd_keys[KEY_UP], kbd_keys[KEY_DOWN], kbd_keys[KEY_SELECT]]

            if event.keyboard_key not in key_events or not self.is_selected():
                Container.handle_event(self, event)
                return

            current_key = self.get_current_key()

            if event.keyboard_key == kbd_keys[KEY_SELECT]:
                self.press_key(current_key.state)
                self.notify_move_listeners()
                return

            transition_map = current_key.state.key_map
            next_key_index = 0
            self.unselect()

            if event.keyboard_key == kbd_keys[KEY_LEFT]:
                index = transition_map[0]
                if index == -3:
                    b = self.get_button_by_index(9)
                    self.exit_keyboard(b)
                    return
                next_key_index = index
            elif event.keyboard_key == kbd_keys[KEY_RIGHT]:
                index = transition_map[1]
                if index == -4:
                    b = self.get_button_by_index(current_key.state.index - 2)
                    self.exit_keyboard(b)
                    return
                next_key_index = index
            elif event.keyboard_key == kbd_keys[KEY_UP]:
                index = transition_map[2]
                if index == -1:
                    self.exit_keyboard(current_key)
                    return    
                else:
                    next_key_index = index
            elif event.keyboard_key == kbd_keys[KEY_DOWN]:
                index = transition_map[3]
                if index == -2 or index == -5:
                    self.exit_keyboard(current_key)
                    return    
                else:
                    next_key_index = index

            self.select_key_by_index(next_key_index)
            self.clean_draw_update()
            self.notify_move_listeners()
        else:
            Container.handle_event(self, event)
            self.notify_move_listeners()
Exemple #3
0
    def handle_event(self, event):
        """ Event handler

        :param event: event to handle
        """
        if not self.visible or event.type == pygame.MOUSEMOTION: return

        mouse_events = [pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN]
        pos = None
        try:
            pos = event.pos
        except:
            pass

        if pos and event.type in mouse_events:
            if self.menu_layout.collidepoint(event.pos):
                if event.type == pygame.MOUSEBUTTONDOWN:
                    return

                self.go_home(None)
                self.redraw_observer()
            else:
                for b in self.navigator.components:
                    if b.bounding_box.collidepoint(event.pos):
                        b.set_selected(True)
                    else:
                        b.set_selected(False)
                    b.clean_draw_update()

        Container.handle_event(self, event)
Exemple #4
0
    def handle_event(self, event):
        """ Handle screen event

        :param event: the event to handle
        """
        if not self.visible or event.type == pygame.MOUSEMOTION:
            return

        mouse_events = [pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN]

        if event.type in mouse_events:
            clicked_menu_item = self.file_menu.get_clicked_menu_button(event.pos[0], event.pos[1])
            navigator_selected = False
            if not self.navigator.is_empty():
                if clicked_menu_item != None:
                    self.navigator.unselect()
                else:
                    for b in self.navigator.components:
                        if b.bounding_box.collidepoint(event.pos):
                            navigator_selected = True
                        else:
                            b.set_selected(False)
                            b.clean_draw_update()
            if navigator_selected:
                self.file_menu.unselect()

        Container.handle_event(self, event)
        self.link_borders()
        self.redraw_observer()
Exemple #5
0
    def handle_event(self, event):
        """ Event handler

        :param event: event to handle
        """
        if not self.visible: return

        pos = None
        try:
            pos = event.pos
        except:
            pass

        if (pos and event.type == pygame.MOUSEBUTTONDOWN and self.menu_layout.collidepoint(pos)) or \
                (event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYDOWN and \
                event.keyboard_key == kbd_keys[KEY_SELECT]):
            self.clicked = True
        elif (pos and event.type == pygame.MOUSEBUTTONUP and self.menu_layout.collidepoint(pos) and self.clicked) or \
                (event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP and \
                event.keyboard_key == kbd_keys[KEY_SELECT] and self.clicked):
            self.go_home(None)
            self.redraw_observer()
            self.clicked = False
        else:
            Container.handle_event(self, event)
Exemple #6
0
 def handle_arrow_key(self, event):
     """ Arrow keys handler
     
     :param event: the event to handle
     """
     Container.handle_event(self, event)
     if self.config[PLAYER_SETTINGS][MUTE] and event.action == pygame.KEYUP:
         event.keyboard_key = kbd_keys[KEY_MUTE]
         self.volume.selected = True
         self.volume.handle_event(event)
         self.current_button = self.volume
     self.update_web_observer()
Exemple #7
0
    def handle_play_key(self, event):
        """ Play/pause keys handler
        
        :param event: the event to handle
        """
        if event.action == pygame.KEYDOWN:
            self.current_button.set_selected(False)
            self.current_button.clean_draw_update()
            self.update_web_observer()
            self.current_button = self.play_button

        Container.handle_event(self, event)
Exemple #8
0
    def handle_event(self, event):
        """ Menu event handler
        
        :param event: menu event
        """
        if not self.visible: return

        if event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP:
            key_events = [
                kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT], kbd_keys[KEY_UP],
                kbd_keys[KEY_DOWN]
            ]
            i = None
            if event.keyboard_key in key_events:
                i = self.get_selected_index()
                if i == None:
                    return
                col = int(i % self.cols)
                row = int(i / self.cols)

            if event.keyboard_key == kbd_keys[KEY_SELECT]:
                self.select_action()
                return

            if event.keyboard_key == kbd_keys[KEY_LEFT]:
                if col == 0:
                    i = i + self.cols - 1
                else:
                    i = i - 1
            elif event.keyboard_key == kbd_keys[KEY_RIGHT]:
                if col == self.cols - 1:
                    i = i - self.cols + 1
                else:
                    i = i + 1
            elif event.keyboard_key == kbd_keys[KEY_UP]:
                cp = getattr(self, "current_page", None)
                if row == 0 or (cp and ((cp - 1) * self.rows) == row):
                    i = i + (self.rows - 1) * self.cols
                else:
                    i = i - self.cols
            elif event.keyboard_key == kbd_keys[KEY_DOWN]:
                if row == self.rows - 1:
                    i = int(i % self.cols)
                else:
                    i = i + self.cols

            if self.is_enabled(i):
                self.unselect()
                self.select_by_index(i)
        else:
            Container.handle_event(self, event)
Exemple #9
0
    def handle_event(self, event):
        """ Menu event handler
        
        :param event: menu event
        """
        if not self.visible: return
        
        if event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP:
            key_events = [kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT], kbd_keys[KEY_UP], kbd_keys[KEY_DOWN]]            
            if event.keyboard_key in key_events:
                i = self.get_selected_index()
                if i == None:
                    return
                col = int(i % self.cols)
                row = int(i / self.cols)
            
            if event.keyboard_key == kbd_keys[KEY_SELECT]:
                self.select_action()
                return
             
            if event.keyboard_key == kbd_keys[KEY_LEFT]:                              
                if col == 0:
                    i = i + self.cols - 1
                else:
                    i = i - 1                
            elif event.keyboard_key == kbd_keys[KEY_RIGHT]:
                if col == self.cols - 1:
                    i = i - self.cols + 1
                else:
                    i = i + 1
            elif event.keyboard_key == kbd_keys[KEY_UP]:
                if row == 0:
                    i = i + (self.rows - 1) * self.cols
                else:
                    i = i - self.cols
            elif event.keyboard_key == kbd_keys[KEY_DOWN]:
                if row == self.rows - 1:
                    i = int(i % self.cols)
                else:
                    i = i + self.cols
                
            if self.is_enabled(i):
                self.unselect()
                self.select_by_index(i)                  
        else:
            Container.handle_event(self, event) 

            
Exemple #10
0
    def handle_mute_key(self, event):
        """ Mute key handler
        
        :param event: the event to handle
        """
        if not self.volume.visible:
            return

        if event.action == pygame.KEYDOWN:
            self.current_button.set_selected(False)
            self.current_button.clean_draw_update()
            self.update_web_observer()
            self.volume.set_knob_on()
            self.current_button = self.volume

        Container.handle_event(self, event)
Exemple #11
0
    def handle_mouse(self, event):
        """ Mouse event dispatcher
        
        :param event: the event to handle
        """
        button = self.get_collided_button(event)
        if button and event.type == pygame.MOUSEBUTTONDOWN:
            self.handle_mouse_down(event, button)
        elif button and event.type == pygame.MOUSEBUTTONUP:
            self.handle_mouse_up(event, button)
        elif event.type == pygame.MOUSEMOTION:
            self.handle_mouse_motion(event)
            return

        Container.handle_event(self, event)
        self.redraw_observer()
Exemple #12
0
    def handle_event(self, event):
        """ Screensaver screen event handler
        
        :param event: event to handle
        """
        if not self.visible: return

        if event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP:
            if event.keyboard_key == kbd_keys[
                    KEY_UP] or event.keyboard_key == kbd_keys[KEY_DOWN]:
                if self.top_menu_enabled:
                    index = self.saver_menu.get_selected_index()
                    if event.keyboard_key == kbd_keys[
                            KEY_DOWN] and index <= self.saver_menu.cols - 1:
                        self.saver_menu.handle_event(event)
                    elif event.keyboard_key == kbd_keys[
                            KEY_UP] and index >= self.saver_menu.cols:
                        self.saver_menu.handle_event(event)
                    else:
                        self.top_menu_enabled = False
                        self.delay_menu.unselect()
                        s = len(self.delay_menu.delays)
                        if index > (s - 1):
                            index = s - 1
                        self.delay_menu.select_by_index(index)
                else:
                    index = self.delay_menu.get_selected_index()
                    self.top_menu_enabled = True
                    self.saver_menu.unselect()
                    s = len(self.delay_menu.delays)
                    if index == (s - 1):
                        index = len(self.saver_menu.savers) - 1
                    else:
                        index += self.saver_menu.cols
                    self.saver_menu.select_by_index(index)
            elif event.keyboard_key == kbd_keys[KEY_HOME]:
                self.navigator.home_button.handle_event(event)
            elif event.keyboard_key == kbd_keys[KEY_PLAY_PAUSE]:
                self.navigator.player_button.handle_event(event)
            else:
                if self.top_menu_enabled:
                    self.saver_menu.handle_event(event)
                else:
                    self.delay_menu.handle_event(event)
        else:
            Container.handle_event(self, event)
Exemple #13
0
 def handle_select_key(self, event):
     """ Select key handler
     
     :param event: the event to handle
     """
     if event.action == pygame.KEYUP:
         if self.order_button and self.order_button.selected and not self.order_popup.visible:
             self.order_button.handle_event(event)
         elif self.info_button and self.info_button.selected and not self.info_popup.visible:
             self.info_button.handle_event(event)
         else:
             if not ((self.order_button and self.order_popup.visible) or
                     (self.info_button and self.info_popup.visible)):
                 if hasattr(self, "current_button"):
                     self.current_button.handle_event(event)
             else:
                 Container.handle_event(self, event)
             self.update_web_observer()
     elif event.action == pygame.KEYDOWN:
         if hasattr(self, "current_button"):
             self.current_button.handle_event(event)
Exemple #14
0
    def handle_event(self, event):
        """ Menu event handler
        
        :param event: menu event
        """
        if not self.visible: return
        
        if event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD:
            key_events = [kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT], kbd_keys[KEY_UP], kbd_keys[KEY_DOWN], kbd_keys[KEY_PAGE_UP], kbd_keys[KEY_PAGE_DOWN]]
            if event.keyboard_key not in key_events:
                return
            
            if event.action == pygame.KEYUP:
                self.key_up(event)
            elif event.action == pygame.KEYDOWN:
                self.key_down(event)                
        else:
            if not self.bounding_box.collidepoint(event.pos):
                return
            
            if event.type == pygame.MOUSEBUTTONDOWN:
                selected_slider = self.current_slider                
                for i, b in enumerate(self.sliders):
                    if b.slider.bounding_box.collidepoint(event.pos):
                        selected_slider = i
                        break
                
                if selected_slider != self.current_slider:
                    self.deactivate_current_slider()
                    self.current_slider = selected_slider

            Container.handle_event(self, event)
            
            if event.type == pygame.MOUSEBUTTONUP:
                slider = self.sliders[self.current_slider].slider
                slider.set_knob_on()
                slider.notify_slide_listeners()
Exemple #15
0
    def handle_event_common(self, event):
        """ Handle screen event

        :param event: the event to handle
        """
        if not self.visible or event.type == pygame.MOUSEMOTION:
            return

        mouse_events = [pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN]

        if event.type in mouse_events:
            clicked_menu_item = self.menu.get_clicked_menu_button(
                event.pos[0], event.pos[1])
            if clicked_menu_item != None:
                self.navigator.unselect()
                clicked_menu_item.handle_event(event)
            elif clicked_menu_item == None:
                clicked_button = self.navigator.get_clicked_button(event)
                if clicked_button == None:
                    Container.handle_event(self, event)
                else:
                    if len(self.menu.buttons.values()) > 0:
                        self.menu.unselect()
                    self.navigator.unselect()
                    clicked_button.handle_event(event)
        elif event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and (
                event.action == pygame.KEYUP
                or event.action == pygame.KEYDOWN):
            menu_selected = self.menu.get_selected_index()
            navigator_selected = self.navigator.is_selected()

            if menu_selected != None:
                self.menu.handle_event(event)
            elif navigator_selected:
                self.navigator.handle_event(event)
        elif event.type == SELECT_EVENT_TYPE:
            Container.handle_event(self, event)
Exemple #16
0
    def handle_event(self, event):
        """ Menu event handler
        
        :param event: menu event
        """
        if not self.visible: return
        
        if event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP:
            key_events = [kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT], kbd_keys[KEY_UP], kbd_keys[KEY_DOWN]]
            i = None            
            if event.keyboard_key in key_events:
                i = self.get_selected_index()
                if i == None:
                    return

                if self.horizontal_layout:
                    row = int(i / self.cols)
                else:
                    row = int(i % self.rows)

                first_index = self.components[0].state.index
                last_index = self.components[len(self.buttons) - 1].state.index

            if event.keyboard_key == kbd_keys[KEY_SELECT]:
                self.select_action()
                return
             
            if event.keyboard_key == kbd_keys[KEY_LEFT]:
                if i == first_index:
                    if self.exit_menu(self.exit_top_y, event, self.exit_left_x):
                        return
                else:
                    i -= 1
            elif event.keyboard_key == kbd_keys[KEY_RIGHT]:
                if i == last_index:
                    if self.exit_menu(self.exit_top_y, event, self.exit_right_x):
                        return
                else:
                    i += 1
            elif event.keyboard_key == kbd_keys[KEY_UP]:
                cp = getattr(self, "current_page", None)
                if self.horizontal_layout:
                    if row == 0 or (cp and ((cp - 1) * self.rows) == row):
                        if self.exit_menu(self.exit_top_y, event):
                            return
                        i = i + (self.rows - 1) * self.cols
                    else:
                        i = i - self.cols
                else:
                    if row == 0:
                        if self.exit_menu(self.exit_top_y, event):
                            return
                        i = i + self.rows - 1
                    else:
                        i = i - 1
            elif event.keyboard_key == kbd_keys[KEY_DOWN]:
                selected_item = self.get_selected_item()
                if selected_item != None:
                    x = selected_item.bounding_box.x + selected_item.bounding_box.w / 2
                    h = selected_item.bounding_box.h
                    y = selected_item.bounding_box.y + h + (h / 2)
                    button_below = self.get_clicked_menu_button(x, y)
                    if button_below == None:
                        if self.exit_menu(self.exit_bottom_y, event):
                            return    

                if self.horizontal_layout:
                    if row == self.rows - 1:
                        if self.exit_menu(self.exit_bottom_y, event):
                            return
                        i = int(i % self.cols)
                    else:
                        i = i + self.cols
                else:
                    if row == self.rows - 1:
                        if self.exit_menu(self.exit_bottom_y, event):
                            return
                        i = i - self.rows + 1
                    else:
                        i = i + 1
                
            if self.is_enabled(i):
                self.unselect()
                self.select_by_index(i)
            else:
                if not self.is_enabled(i + 1) and self.exit_menu(self.exit_top_y, event, self.exit_right_x):
                    return
        elif event.type == SELECT_EVENT_TYPE:
            if event.source == self:
                return
            self.handle_select_action(event.x, event.y)
        else:
            Container.handle_event(self, event) 
Exemple #17
0
 def handle_event(self, event):
     """ Handle screen event
     
     :param event: the event to handle
     """
     if not self.visible: return
     
     if not (event.type == USER_EVENT_TYPE and event.sub_type == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP):
         Container.handle_event(self, event) 
         return
     
     keys = [kbd_keys[KEY_SELECT], kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT], kbd_keys[KEY_UP], kbd_keys[KEY_DOWN]]            
     if event.keyboard_key == kbd_keys[KEY_SELECT]:
         self.menu_functions[self.menu_index]()
     elif event.keyboard_key == kbd_keys[KEY_RIGHT]: 
         if self.menu_index == MINUTES_DECREMENT_WAKE_UP:
             self.wake_up_menu.clock.reset_key()
             self.sleep_menu.clock.set_key_position(HOURS_INCREMENT_SLEEP)
             self.menu_index = HOURS_INCREMENT_SLEEP
         else:
             if self.menu_index == MINUTES_DECREMENT_SLEEP:
                 self.sleep_menu.clock.reset_key()
             self.menu_index += 1
             self.wake_up_menu.clock.set_key_position(self.menu_index)
             self.sleep_menu.clock.set_key_position(self.menu_index)
     elif event.keyboard_key == kbd_keys[KEY_LEFT]: 
         if self.menu_index == HOURS_INCREMENT_SLEEP:
             self.sleep_menu.clock.reset_key()
             self.wake_up_menu.clock.set_key_position(MINUTES_DECREMENT_WAKE_UP)
             self.menu_index = MINUTES_DECREMENT_WAKE_UP
         else:
             if self.menu_index == HOURS_INCREMENT_WAKE_UP:
                 self.wake_up_menu.clock.reset_key()
             self.menu_index -= 1
             self.wake_up_menu.clock.set_key_position(self.menu_index)
             self.sleep_menu.clock.set_key_position(self.menu_index)
     elif event.keyboard_key == kbd_keys[KEY_UP]:
         if self.menu_index == HOURS_INCREMENT_SLEEP:
             self.handle_up_down(HOURS_DECREMENT_WAKE_UP, self.wake_up_menu, self.sleep_menu, self.wake_up_menu)
         elif self.menu_index == MINUTES_INCREMENT_SLEEP:
             self.handle_up_down(MINUTES_DECREMENT_WAKE_UP, self.wake_up_menu, self.sleep_menu, self.wake_up_menu)
         elif self.menu_index == HOURS_DECREMENT_SLEEP:
             self.handle_up_down(HOURS_INCREMENT_SLEEP, self.sleep_menu)
         elif self.menu_index == MINUTES_DECREMENT_SLEEP:
             self.handle_up_down(MINUTES_INCREMENT_SLEEP, self.sleep_menu)
         elif self.menu_index == HOURS_INCREMENT_WAKE_UP:
             self.handle_up_down(HOURS_DECREMENT_SLEEP, self.sleep_menu, self.wake_up_menu, self.sleep_menu)
         elif self.menu_index == MINUTES_INCREMENT_WAKE_UP:
             self.handle_up_down(MINUTES_DECREMENT_SLEEP, self.sleep_menu, self.wake_up_menu, self.sleep_menu)
         elif self.menu_index == HOURS_DECREMENT_WAKE_UP:
             self.handle_up_down(HOURS_INCREMENT_WAKE_UP, self.wake_up_menu)
         elif self.menu_index == MINUTES_DECREMENT_WAKE_UP:
             self.handle_up_down(MINUTES_INCREMENT_WAKE_UP, self.wake_up_menu)
     elif event.keyboard_key == kbd_keys[KEY_DOWN]:
         if self.menu_index == HOURS_INCREMENT_SLEEP:
             self.handle_up_down(HOURS_DECREMENT_SLEEP, self.sleep_menu)
         elif self.menu_index == MINUTES_INCREMENT_SLEEP:
             self.handle_up_down(MINUTES_DECREMENT_SLEEP, self.sleep_menu)
         elif self.menu_index == HOURS_DECREMENT_SLEEP:
             self.handle_up_down(HOURS_INCREMENT_WAKE_UP, self.wake_up_menu, self.sleep_menu, self.wake_up_menu)
         elif self.menu_index == MINUTES_DECREMENT_SLEEP:
             self.handle_up_down(MINUTES_INCREMENT_WAKE_UP, self.wake_up_menu, self.sleep_menu, self.wake_up_menu)
         elif self.menu_index == HOURS_INCREMENT_WAKE_UP:
             self.handle_up_down(HOURS_DECREMENT_WAKE_UP, self.wake_up_menu)
         elif self.menu_index == MINUTES_INCREMENT_WAKE_UP:
             self.handle_up_down(MINUTES_DECREMENT_WAKE_UP, self.wake_up_menu)
         elif self.menu_index == HOURS_DECREMENT_WAKE_UP:
             self.handle_up_down(HOURS_INCREMENT_SLEEP, self.sleep_menu, self.wake_up_menu, self.sleep_menu)
         elif self.menu_index == MINUTES_DECREMENT_WAKE_UP:
             self.handle_up_down(MINUTES_INCREMENT_SLEEP, self.sleep_menu, self.wake_up_menu, self.sleep_menu)
         
     if event.keyboard_key in keys and self.update_web_observer != None:
         self.update_web_observer()
         
     Container.handle_event(self, event) 
Exemple #18
0
    def handle_event(self, event):
        """ Handle screen event

        :param event: the event to handle
        """
        if not self.visible or event.type == pygame.MOUSEMOTION:
            return

        mouse_events = [pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN]

        if event.type in mouse_events:
            self.handle_mouse_event(event)
            return

        if event.type == SELECT_EVENT_TYPE:
            self.handle_select_action(event)
            return

        if not (event.type == USER_EVENT_TYPE and event.sub_type
                == SUB_TYPE_KEYBOARD and event.action == pygame.KEYUP):
            Container.handle_event(self, event)
            return

        keys = [
            kbd_keys[KEY_SELECT], kbd_keys[KEY_LEFT], kbd_keys[KEY_RIGHT],
            kbd_keys[KEY_UP], kbd_keys[KEY_DOWN]
        ]
        if event.keyboard_key in keys and self.menu_index == -1:
            if self.current_button == self.sleep_menu.sleep_button:
                self.sleep_menu.sleep_button.handle_event(event)
                if self.config[TIMER][SLEEP]:
                    self.sleep_menu.sleep_button.set_selected(True)
                    self.sleep_menu.sleep_button.clean_draw_update()
                else:
                    if event.keyboard_key == kbd_keys[KEY_SELECT]:
                        self.select_home()
            elif self.current_button == self.sleep_menu.poweroff_button:
                self.sleep_menu.poweroff_button.handle_event(event)
                if self.config[TIMER][POWEROFF]:
                    self.sleep_menu.poweroff_button.set_selected(True)
                    self.sleep_menu.poweroff_button.clean_draw_update()
                else:
                    if event.keyboard_key == kbd_keys[KEY_SELECT]:
                        self.select_home()
            elif self.current_button == self.wake_up_menu.button:
                self.wake_up_menu.button.handle_event(event)
                if self.config[TIMER][WAKE_UP]:
                    self.wake_up_menu.button.set_selected(True)
                    self.wake_up_menu.button.clean_draw_update()
                else:
                    if event.keyboard_key == kbd_keys[KEY_SELECT]:
                        self.select_home()
            else:
                self.navigator.handle_event(event)
            return

        if event.keyboard_key == kbd_keys[KEY_SELECT]:
            self.menu_functions[self.menu_index]()
        elif event.keyboard_key == kbd_keys[KEY_RIGHT]:
            if self.menu_index == MINUTES_INCREMENT_WAKE_UP:
                self.wake_up_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.enter_wake_up_x,
                                          self.enter_wake_up_y,
                                          self.wake_up_menu)
            elif self.menu_index == MINUTES_DECREMENT_WAKE_UP:
                self.wake_up_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.enter_naviagtor_x,
                                          self.enter_naviagtor_y,
                                          self.wake_up_menu)
            elif self.menu_index == MINUTES_INCREMENT_SLEEP:
                self.sleep_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_sleep_x,
                                          self.exit_sleep_incr_y,
                                          self.sleep_menu)
            elif self.menu_index == MINUTES_DECREMENT_SLEEP:
                self.sleep_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_sleep_x,
                                          self.exit_sleep_decr_y,
                                          self.sleep_menu)
            else:
                self.menu_index += 1
                self.wake_up_menu.clock.set_key_position(self.menu_index)
                self.sleep_menu.clock.set_key_position(self.menu_index)
        elif event.keyboard_key == kbd_keys[KEY_LEFT]:
            if self.menu_index == HOURS_INCREMENT_WAKE_UP:
                self.wake_up_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.enter_poweroff_x,
                                          self.enter_poweroff_y,
                                          self.wake_up_menu)
            elif self.menu_index == HOURS_DECREMENT_WAKE_UP:
                self.wake_up_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_wake_up_x,
                                          self.exit_wake_up_y,
                                          self.wake_up_menu)
            elif self.menu_index == HOURS_INCREMENT_SLEEP:
                self.sleep_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_naviagtor_x,
                                          self.exit_naviagtor_y,
                                          self.sleep_menu)
            elif self.menu_index == HOURS_DECREMENT_SLEEP:
                self.sleep_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.enter_sleep_x,
                                          self.enter_sleep_y, self.sleep_menu)
            else:
                self.menu_index -= 1
                self.wake_up_menu.clock.set_key_position(self.menu_index)
                self.sleep_menu.clock.set_key_position(self.menu_index)
        elif event.keyboard_key == kbd_keys[KEY_UP]:
            if self.menu_index == HOURS_INCREMENT_SLEEP:
                self.sleep_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_sleep_top_hour_x,
                                          self.exit_wake_up_bottom_y,
                                          self.sleep_menu)
            elif self.menu_index == MINUTES_INCREMENT_SLEEP:
                self.sleep_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_sleep_top_min_x,
                                          self.exit_wake_up_bottom_y,
                                          self.sleep_menu)
            elif self.menu_index == HOURS_DECREMENT_SLEEP:
                self.handle_up_down(HOURS_INCREMENT_SLEEP, self.sleep_menu)
            elif self.menu_index == MINUTES_DECREMENT_SLEEP:
                self.handle_up_down(MINUTES_INCREMENT_SLEEP, self.sleep_menu)
            elif self.menu_index == HOURS_INCREMENT_WAKE_UP:
                self.handle_up_down(HOURS_DECREMENT_SLEEP, self.sleep_menu,
                                    self.wake_up_menu, self.sleep_menu)
            elif self.menu_index == MINUTES_INCREMENT_WAKE_UP:
                self.handle_up_down(MINUTES_DECREMENT_SLEEP, self.sleep_menu,
                                    self.wake_up_menu, self.sleep_menu)
            elif self.menu_index == HOURS_DECREMENT_WAKE_UP:
                self.handle_up_down(HOURS_INCREMENT_WAKE_UP, self.wake_up_menu)
            elif self.menu_index == MINUTES_DECREMENT_WAKE_UP:
                self.handle_up_down(MINUTES_INCREMENT_WAKE_UP,
                                    self.wake_up_menu)
        elif event.keyboard_key == kbd_keys[KEY_DOWN]:
            if self.menu_index == HOURS_INCREMENT_SLEEP:
                self.handle_up_down(HOURS_DECREMENT_SLEEP, self.sleep_menu)
            elif self.menu_index == MINUTES_INCREMENT_SLEEP:
                self.handle_up_down(MINUTES_DECREMENT_SLEEP, self.sleep_menu)
            elif self.menu_index == HOURS_DECREMENT_SLEEP:
                self.handle_up_down(HOURS_INCREMENT_WAKE_UP, self.wake_up_menu,
                                    self.sleep_menu, self.wake_up_menu)
            elif self.menu_index == MINUTES_DECREMENT_SLEEP:
                self.handle_up_down(MINUTES_INCREMENT_WAKE_UP,
                                    self.wake_up_menu, self.sleep_menu,
                                    self.wake_up_menu)
            elif self.menu_index == HOURS_INCREMENT_WAKE_UP:
                self.handle_up_down(HOURS_DECREMENT_WAKE_UP, self.wake_up_menu)
            elif self.menu_index == MINUTES_INCREMENT_WAKE_UP:
                self.handle_up_down(MINUTES_DECREMENT_WAKE_UP,
                                    self.wake_up_menu)
            elif self.menu_index == HOURS_DECREMENT_WAKE_UP:
                self.wake_up_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_wake_up_bottom_hour_x,
                                          self.exit_wake_up_bottom_y,
                                          self.wake_up_menu)
            elif self.menu_index == MINUTES_DECREMENT_WAKE_UP:
                self.wake_up_menu.clock.reset_key()
                self.menu_index = -1
                self.util.post_exit_event(self.exit_wake_up_bottom_min_x,
                                          self.exit_wake_up_bottom_y,
                                          self.wake_up_menu)
        else:
            Container.handle_event(self, event)

        if event.keyboard_key in keys and self.update_web_observer != None:
            self.update_web_observer()
Exemple #19
0
    def handle_event(self, event):
        """ Event handler

        :param event: event to handle
        """
        if not self.visible: return

        mouse_events = [pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN]
        
        if event.type in mouse_events and getattr(self, "menu", None) and getattr(self, "navigator", None):
            event_component = None

            for comp in self.menu.components:
                if getattr(comp, "state", None):
                    bb = comp.state.bounding_box
                else:
                    bb = comp.bounding_box

                if bb == None:
                    continue

                if bb.collidepoint(event.pos):
                    event_component = comp
                    for c in self.menu.components:
                        if hasattr(c, "set_selected") and c != comp:
                            c.set_selected(False)
                            c.clean_draw_update()

            if event_component:
                self.navigator.unselect()
                event_component.handle_event(event)
                if hasattr(self.menu, "current_slider"):
                    self.menu.current_slider = event_component.id
                if self.update_web_observer:
                    self.update_web_observer()
                return
            
            for comp in self.navigator.components:
                if getattr(comp, "state", None):
                    bb = comp.state.bounding_box
                else:
                    bb = comp.bounding_box

                if bb == None:
                    continue

                if bb.collidepoint(event.pos):
                    event_component = comp
                    break
            if event_component:
                for c in self.menu.components:
                    if getattr(c, "selected", False):
                        c.set_selected(False)
                        c.clean_draw_update()
                    elif hasattr(c, "slider"):
                        c.slider.set_knob_off()
                self.navigator.unselect()
                event_component.handle_event(event)
                if self.update_web_observer:
                    self.update_web_observer()
        else:
            Container.handle_event(self, event)
            self.update_web_observer()