def test_process_event_text_ctrl_x(self, _init_pygame: None,
                                       default_ui_manager: UIManager,
                                       _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.set_text('dan')
        text_entry.focus()

        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_a,
                'mod': pygame.KMOD_CTRL,
                'unicode': 'a'
            }))

        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_x,
                'mod': pygame.KMOD_CTRL,
                'unicode': 'x'
            }))

        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_v,
                'mod': pygame.KMOD_CTRL,
                'unicode': 'v'
            }))

        assert processed_key_event and clipboard_paste() == 'dan'
    def test_process_event_text_entered_success(
            self, _init_pygame: None, default_ui_manager: UIManager,
            _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.focus()
        # process a mouse button down event
        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_d,
                'mod': 0,
                'unicode': 'd'
            }))

        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_a,
                'mod': 0,
                'unicode': 'a'
            }))
        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_n,
                'mod': 0,
                'unicode': 'n'
            }))

        assert processed_key_event and text_entry.get_text() == 'dan'
    def test_process_event_text_ctrl_v_select_range(
            self, _init_pygame: None, default_ui_manager: UIManager,
            _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.set_text('dan')
        text_entry.focus()
        text_entry.select_range = [1, 3]

        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_c,
                'mod': pygame.KMOD_CTRL,
                'unicode': 'c'
            }))
        text_entry.select_range = [0, 3]
        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_v,
                'mod': pygame.KMOD_CTRL,
                'unicode': 'v'
            }))

        assert processed_key_event and text_entry.get_text() == 'an'
    def test_focus(self, _init_pygame, default_ui_manager):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.focus()

        assert text_entry.image is not None
Ejemplo n.º 5
0
class Cat(UIWindow):
    def __init__(self, pos, manager, clear, parse, name):
        super().__init__(Rect(pos, (400, 300)), manager, name, resizable=True)
        self.textbox = UITextBox("",
                                 relative_rect=Rect(0, 0, 368, 200),
                                 manager=manager,
                                 container=self,
                                 anchors={
                                     "left": "left",
                                     "right": "right",
                                     "top": "top",
                                     "bottom": "bottom"
                                 })
        self.input = UITextEntryLine(relative_rect=Rect(0, -35, 368, 30),
                                     manager=manager,
                                     container=self,
                                     anchors={
                                         "left": "left",
                                         "right": "right",
                                         "top": "bottom",
                                         "bottom": "bottom"
                                     })
        self.text = ''
        self.manager = manager
        self.input.focus()
        self.clear = clear
        self.parse = parse

    def process_event(self, event):
        super().process_event(event)
        if event.type == 769 and event.key == 13:
            self.text += self.input.get_text() + "<br>"
            self.input.kill()
            self.textbox.kill()
            self.textbox = UITextBox(self.parse(self.text),
                                     relative_rect=Rect(0, 0, 368, 200),
                                     manager=self.manager,
                                     container=self,
                                     anchors={
                                         "left": "left",
                                         "right": "right",
                                         "top": "top",
                                         "bottom": "bottom"
                                     })
            self.input = UITextEntryLine(relative_rect=Rect(0, -35, 368, 30),
                                         manager=self.manager,
                                         container=self,
                                         anchors={
                                             "left": "left",
                                             "right": "right",
                                             "top": "bottom",
                                             "bottom": "bottom"
                                         })
            self.input.focus()

    def kill(self):
        super().kill()
        self.clear.cats.remove(self)
    def test_process_event_text_left(self, _init_pygame: None,
                                     default_ui_manager: UIManager,
                                     _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.set_text('dan')
        text_entry.focus()

        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {'key': pygame.K_LEFT}))

        assert processed_key_event
    def test_process_event_backspace(self, _init_pygame: None,
                                     default_ui_manager: UIManager,
                                     _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.set_text('dan')
        text_entry.focus()
        text_entry.edit_position = 2
        text_entry.start_text_offset = 1

        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {'key': pygame.K_BACKSPACE}))

        assert processed_key_event
    def test_update_cursor_blink(self, _init_pygame,
                                 _display_surface_return_none: None):
        manager = UIManager(
            (800, 600),
            os.path.join("tests", "data", "themes",
                         "ui_text_entry_line_non_default.json"))
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=manager)

        text_entry.focus()
        text_entry.cursor_blink_delay_after_moving_acc = 10.0
        text_entry.update(0.01)
        text_entry.blink_cursor_time_acc = 10.0
        text_entry.update(0.01)
        text_entry.blink_cursor_time_acc = 10.0
        text_entry.update(0.01)
    def test_process_event_text_entered_not_allowed(
            self, _init_pygame: None, default_ui_manager: UIManager,
            _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.focus()

        text_entry.set_allowed_characters(['d', 'a', 'n'])
        # process a mouse button down event
        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_o,
                'mod': 0,
                'unicode': 'o'
            }))

        assert processed_key_event is False and text_entry.get_text() == ''
    def test_update_after_click(self, _init_pygame,
                                _display_surface_return_none: None):
        manager = UIManager(
            (800, 600),
            os.path.join("tests", "data", "themes",
                         "ui_text_entry_line_non_default.json"))
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(0, 0, 200, 30),
                                     manager=manager)

        text_entry.set_text('Wow testing is great so amazing')
        text_entry.focus()

        text_entry.process_event(
            pygame.event.Event(pygame.MOUSEBUTTONDOWN, {
                'button': 1,
                'pos': (30, 15)
            }))
        default_ui_manager.mouse_position = (70, 15)

        text_entry.update(0.01)
    def test_process_event_text_entered_with_select_range(
            self, _init_pygame: None, default_ui_manager: UIManager,
            _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.set_text('Hours and hours of fun writing tests')
        text_entry.focus()
        text_entry.select_range = [1, 9]

        # process a mouse button down event
        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_o,
                'mod': 0,
                'unicode': 'o'
            }))

        assert (processed_key_event is True
                and text_entry.get_text() == 'Ho hours of fun writing tests')
    def test_process_event_text_ctrl_c(self, _init_pygame: None,
                                       _display_surface_return_none: None):
        manager = UIManager(
            (800, 600),
            os.path.join("tests", "data", "themes",
                         "ui_text_entry_line_non_default_2.json"))
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=manager)

        text_entry.set_text('dan')
        text_entry.focus()
        text_entry.select_range = [0, 3]

        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_c,
                'mod': pygame.KMOD_CTRL,
                'unicode': 'c'
            }))
        text_entry.cursor_on = True
        text_entry.redraw_cursor()

        assert processed_key_event and clipboard_paste() == 'dan'
    def test_process_event_text_entered_too_long(
            self, _init_pygame: None, default_ui_manager: UIManager,
            _display_surface_return_none: None):
        text_entry = UITextEntryLine(relative_rect=pygame.Rect(
            100, 100, 200, 30),
                                     manager=default_ui_manager)

        text_entry.set_text_length_limit(3)
        text_entry.focus()

        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_t,
                'mod': 0,
                'unicode': 't'
            }))
        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_e,
                'mod': 0,
                'unicode': 'e'
            }))
        text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_s,
                'mod': 0,
                'unicode': 's'
            }))
        processed_key_event = text_entry.process_event(
            pygame.event.Event(pygame.KEYDOWN, {
                'key': pygame.K_s,
                'mod': 0,
                'unicode': 't'
            }))

        assert processed_key_event is False and text_entry.get_text() == 'tes'
Ejemplo n.º 14
0
 def move(self, squares: Squares, win: pygame.Surface, board):
     if not isinstance(squares, list):
         raise TypeError("The squares arguement must be a list(), not " +
                         str(type(squares))[8:-1] + "().")
     limiting_pos = [[self.min_x, max_x], [self.min_y, self.max_y]]
     max_length = 1
     selected = False
     direction = 0
     max_direction = 8
     direction_offset = 0
     pygame.font.init()
     while (self.x in limiting_pos[0] and self.y in limiting_pos[1]):
         if len(self.pieces) > max_length:
             font = pygame.font.SysFont("comicsans", 40)
             text = font.render(
                 "You can't select that piece because you have already selected a piece. You must either move the already selected piece or unselect it."
             )
             win.blit(txt, ((self.max_x - txt.get_width()) / 2,
                            (self.max_y - txt.get_height()) / 2))
         for event in pygame.event.get():
             if event.type == pygame.K_SPACE or event.type == pygame.K_RETURN:
                 if (self.x, self.y, self.name) in pieces:
                     selected = False
                     self.pieces.pop()
                 else:
                     selected = True
                     self.pieces.append((self.x, self.y, self.name))
         keys = pygame.key.get_pressed()
         if ((keys[pygame.K_RALT] and keys[pygame.K_k]) or
             (keys[pygame.K_LALT] and keys[pygame.K_k])) and not (
                 (keys[pygame.K_RALT] and keys[pygame.K_k]) and
                 (keys[pygame.K_LALT] and keys[pygame.K_k])):
             active = False
             text_input_line = UITextEntryLine(pygame.pygame.Rect(
                 self.x, self.y, self.square_width, self.square_height),
                                               manager=MANAGER)
             text_input_line.disable()
             text_input_line.set_allowed_characters(
                 [d for d in string.digits[1:9]] +
                 [l for l in string.ascii_lowercase[:8]])
             text_input_line.set_text_length_limit(2)
             if active:
                 text_input_line.enable()
                 text_input_line.focus()
                 if keys[pygame.K_RETURN]:
                     text = text_input_line.get_text()
                     file = text[0]
                     rank = int(text[1])
                     move_set = self.get_possible_positions(
                         text[0] + str(text[1]), squares)
                     piece = self.find_piece_from_move_set(
                         move_set, squares)
                     if piece:
                         self.x, self.y = get_window_pos(
                             self.file, self.rank, self.possible_files)
                         original_x, original_y = self.x, self.y
                     else:
                         text = font.render(
                             "You can't move there. There is no knight nearby."
                         )
                         win.blit(text, (self.x, self.y))
             else:
                 text_input_line.disable()
                 text_input_line.unfocus()
         while direction < max_direction:
             self.attacked_pieces = self._update_attacked_pieces(
                 self.x, self.y, self.square_width, self.square_height,
                 squares)
             direction += 1
         direction = 0
     return self.attacked_pieces, (self.piece_x,
                                   self.piece_y), (original_x,
                                                   original_y), self