def test_size(self) -> None: """ Test size. """ menu = MenuUtils.generic_menu(title='menu', theme=TEST_THEME.copy()) menu.render() self.assertEqual(menu.get_height(widget=True), 0) # Adds a button, hide it, then the height should be 0 as well btn = menu.add.button('hidden') btn.hide() self.assertEqual(menu.get_height(widget=True), 0) menu.render() # Get the size of the scrollarea sa = menu.get_scrollarea() sa_height = menu.get_height() - menu.get_menubar().get_height() sa_width = menu.get_width() self.assertEqual(sa.get_world_size()[0], sa_width) self.assertEqual(sa.get_world_size()[1], sa_height) rect = sa.get_view_rect() self.assertEqual(rect.x, 0) self.assertEqual(rect.y, 155) self.assertEqual(rect.width, sa_width) self.assertEqual(rect.height, sa_height) self.assertEqual(sa.get_hidden_width(), 0) self.assertEqual(sa.get_hidden_height(), 0) rect = sa.to_world_position(btn.get_rect()) self.assertEqual(rect.x, 0) self.assertEqual(rect.y, -155) self.assertEqual(rect.width, btn.get_width()) self.assertEqual(rect.height, btn.get_height()) pos_rect = sa.to_world_position((10, 10)) self.assertEqual(pos_rect, (10, -145)) self.assertFalse(sa.is_scrolling()) self.assertEqual(sa.get_menu(), menu) sa._on_vertical_scroll(50) sa._on_horizontal_scroll(50) # Remove the world of surface world = sa._world sa._world = None self.assertEqual(sa.get_world_size(), (0, 0)) sa._world = world # Test collide event = PygameEventUtils.mouse_click(100, 100, inlist=False) self.assertFalse(sa.collide(btn, event)) # Create virtual rect from button rect_virtual = sa.to_real_position(btn.get_rect()) event_click_widget = PygameEventUtils.middle_rect_click(rect_virtual, inlist=False) self.assertTrue(sa.collide(btn, event_click_widget))
def test_example_other_scrollbar() -> None: """ Test scrollbar example. """ pygame.event.post(PygameEventUtils.keydown(pygame.K_v, inlist=False)) pygame.event.post(PygameEventUtils.keydown(pygame.K_h, inlist=False)) scrollbar.main(test=True) scrollbar.h_changed(1) scrollbar.v_changed(1)
def test_example_other_calculator(self) -> None: """ Test calculator example. """ app = calculator.main(test=True) app.process_events( PygameEventUtils.keydown([ pygame.K_1, pygame.K_2, pygame.K_3, pygame.K_4, pygame.K_5, pygame.K_PLUS ])) self.assertEqual(app.prev, '12345') self.assertEqual(app.op, '+') app.process_events( PygameEventUtils.keydown( [pygame.K_6, pygame.K_7, pygame.K_8, pygame.K_9, pygame.K_0])) self.assertEqual(app.curr, '67890') app.process_events(PygameEventUtils.keydown(pygame.K_EQUALS)) self.assertEqual(app.op, '') self.assertEqual(app.curr, '80235') self.assertEqual(app.prev, '') app.process_events(PygameEventUtils.keydown([pygame.K_x, pygame.K_2])) self.assertEqual(app.op, 'x') self.assertEqual(app.curr, '2') self.assertEqual(app.prev, '80235') app.process_events(PygameEventUtils.keydown([pygame.K_x])) self.assertEqual(app.op, 'x') self.assertEqual(app.curr, '') self.assertEqual(app.prev, '160470') app.process_events( PygameEventUtils.keydown([pygame.K_PLUS, pygame.K_3, pygame.K_0])) self.assertEqual(app.op, '+') self.assertEqual(app.curr, '30') self.assertEqual(app.prev, '160470') app.process_events(PygameEventUtils.keydown(pygame.K_EQUALS)) self.assertEqual(app.op, '') self.assertEqual(app.curr, '160500') self.assertEqual(app.prev, '') app.process_events( PygameEventUtils.keydown( [pygame.K_SLASH, pygame.K_5, pygame.K_MINUS])) self.assertEqual(app.op, '-') self.assertEqual(app.curr, '') self.assertEqual(app.prev, '32100') app.process_events( PygameEventUtils.keydown([ pygame.K_3, pygame.K_2, pygame.K_1, pygame.K_0, pygame.K_EQUALS ])) self.assertEqual(app.op, '') self.assertEqual(app.curr, '28890') self.assertEqual(app.prev, '') app.process_events( PygameEventUtils.keydown([pygame.K_9, pygame.K_BACKSPACE])) self.assertEqual(app.op, '') self.assertEqual(app.curr, '') self.assertEqual(app.prev, '') test_reset_surface()
def test_example_other_ui_solar_system(self) -> None: """ Test solar system. """ app = ui_solarsystem.main(test=True) self.assertFalse(app.menu._disable_draw) app.process_events(PygameEventUtils.keydown([pygame.K_p]), app.menu) self.assertTrue(app.menu._disable_draw) app.process_events( PygameEventUtils.keydown( [pygame.K_p, pygame.K_q, pygame.K_e, pygame.K_s, pygame.K_c]), app.menu) self.assertFalse(app.menu._disable_draw)
def test_example_other_scrollbar_area() -> None: """ Test scrollbar area example. """ pygame.event.post( PygameEventUtils.keydown(pygame.K_ESCAPE, inlist=False)) scrollbar_area.main(test=True)
def test_double_discrete(self) -> None: """ Test double range slider with discrete values. """ menu = MenuUtils.generic_menu() rv = [0, 1, 2, 3, 4, 5] # Double slider discrete slider = pygame_menu.widgets.RangeSlider( 'Range', range_text_value_tick_number=3, range_values=rv, default_value=(1, 4)) menu.add.generic_widget(slider, True) slider.draw(surface) # Test set values slider.set_value([1, 2]) self.assertEqual(slider.get_value(), (1, 2)) # Test invalid values self.assertRaises(AssertionError, lambda: slider.set_value((1.1, 2.2))) self.assertRaises(AssertionError, lambda: slider.set_value((1, 1))) self.assertRaises(AssertionError, lambda: slider.set_value((2, 1))) self.assertRaises(AssertionError, lambda: slider.set_value(1)) # Test left/right self.assertTrue( slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True))) self.assertEqual(slider.get_value(), (0, 2)) self.assertFalse( slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True))) self.assertEqual(slider.get_value(), (0, 2)) self.assertTrue( slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True))) self.assertEqual(slider.get_value(), (1, 2)) self.assertFalse( slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True))) self.assertEqual(slider.get_value(), (1, 2)) slider._update_value(0.99) self.assertEqual(slider.get_value(), (1, 2)) self.assertEqual( slider._get_slider_inflate_rect(0, to_absolute_position=True), pygame.Rect(301, 209, 15, 28))
def test_example_game_selector(self) -> None: """ Test game selector example. """ game_selector.main(test=True) font = MenuUtils.load_font(MenuUtils.random_font(), 5) game_selector.play_function(['EASY'], font, test=True) pygame.event.post( PygameEventUtils.keydown(pygame.K_ESCAPE, inlist=False)) game_selector.play_function(['MEDIUM'], font, test=True) pygame.event.post( PygameEventUtils.keydown(pygame.K_ESCAPE, inlist=False)) game_selector.play_function(['HARD'], font, test=True) self.assertRaises( ValueError, lambda: game_selector.play_function(['U'], font, test=True)) game_selector.change_difficulty(('HARD', 1), 'HARD')
def test_surface_widget(self) -> None: """ Test surface widget. """ menu = MenuUtils.generic_menu() surf = pygame.Surface((150, 150)) surf.fill((255, 192, 203)) surf_widget = menu.add.surface(surf, font_color='red') self.assertEqual(surf_widget.get_size(), (166, 158)) self.assertEqual(surf_widget.get_size(apply_padding=False), (150, 150)) self.assertEqual(surf_widget.get_surface(), surf) self.assertEqual(surf_widget._font_color, (70, 70, 70, 255)) # not red self.assertRaises(WidgetTransformationNotImplemented, lambda: surf_widget.rotate(10)) self.assertEqual(surf_widget._angle, 0) self.assertRaises(WidgetTransformationNotImplemented, lambda: surf_widget.resize(10, 10)) self.assertFalse(surf_widget._scale[0]) self.assertEqual(surf_widget._scale[1], 1) self.assertEqual(surf_widget._scale[2], 1) self.assertRaises(WidgetTransformationNotImplemented, lambda: surf_widget.scale(100, 100)) self.assertFalse(surf_widget._scale[0]) self.assertEqual(surf_widget._scale[1], 1) self.assertEqual(surf_widget._scale[2], 1) self.assertRaises(WidgetTransformationNotImplemented, lambda: surf_widget.flip(True, True)) self.assertFalse(surf_widget._flip[0]) self.assertFalse(surf_widget._flip[1]) self.assertRaises(WidgetTransformationNotImplemented, lambda: surf_widget.set_max_width(100)) self.assertIsNone(surf_widget._max_width[0]) self.assertRaises(WidgetTransformationNotImplemented, lambda: surf_widget.set_max_height(100)) self.assertIsNone(surf_widget._max_height[0]) surf_widget.set_title('epic') self.assertEqual(surf_widget.get_title(), '') new_surface = pygame.Surface((160, 160)) new_surface.fill((255, 192, 203)) inner_surface = pygame.Surface((80, 80)) inner_surface.fill((75, 0, 130)) new_surface.blit(inner_surface, (40, 40)) surf_widget.set_surface(new_surface) self.assertEqual(surf_widget.get_size(apply_padding=False), (160, 160)) menu.draw(surface) surf_widget.update(PygameEventUtils.mouse_motion(surf_widget)) surf_widget.draw(surface)
def test_image_widget(self) -> None: """ Test image widget. """ menu = MenuUtils.generic_menu() image = menu.add.image(pygame_menu.baseimage.IMAGE_EXAMPLE_GRAY_LINES, font_color=(2, 9)) image.set_title('epic') self.assertEqual(image.get_title(), '') self.assertEqual(image.get_image(), image._image) image.update(PygameEventUtils.mouse_motion(image)) self.assertEqual(image.get_height(apply_selection=True), 264) self.assertFalse(image._selected) self.assertEqual(image.get_selected_time(), 0) # Test transformations self.assertEqual(image.get_size(), (272, 264)) image.scale(2, 2) self.assertEqual(image.get_size(), (528, 520)) image.resize(500, 500) # Remove padding image.set_padding(0) self.assertEqual(image.get_size(), (500, 500)) # Set max width image.set_max_width(400) self.assertEqual(image.get_size(), (400, 500)) image.set_max_width(800) self.assertEqual(image.get_size(), (400, 500)) image.set_max_width(300, scale_height=True) self.assertEqual(image.get_size(), (300, 375)) # Set max height image.set_max_height(400) self.assertEqual(image.get_size(), (300, 375)) image.set_max_height(300) self.assertEqual(image.get_size(), (300, 300)) image.set_max_height(200, scale_width=True) self.assertEqual(image.get_size(), (200, 200)) self.assertEqual(image.get_angle(), 0) image.rotate(90) self.assertEqual(image.get_angle(), 90) image.rotate(60) self.assertEqual(image.get_angle(), 60) # Flip image.flip(True, True) self.assertEqual(image._flip, (True, True)) image.flip(False, False) self.assertEqual(image._flip, (False, False)) image.draw(surface)
def test_overflow_removal(self) -> None: """ Test text with max width and right overflow removal. """ if SYS_PLATFORM_OSX: return menu = MenuUtils.generic_menu() menu._copy_theme() menu._theme.widget_font_size = 20 textinput = menu.add.text_input('Some long text: ', maxwidth=19, textinput_id='long_text', input_underline='_') self.assertRaises(WidgetTransformationNotImplemented, lambda: textinput.resize()) self.assertRaises(WidgetTransformationNotImplemented, lambda: textinput.set_max_width()) self.assertRaises(WidgetTransformationNotImplemented, lambda: textinput.set_max_height()) self.assertRaises(WidgetTransformationNotImplemented, lambda: textinput.scale()) self.assertRaises(WidgetTransformationNotImplemented, lambda: textinput.rotate()) textinput.flip(True, True) self.assertEqual(textinput._flip, (False, True)) # noinspection SpellCheckingInspection textinput.set_value('aaaaaaaaaaaaaaaaaaaaaaaaaa') self.assertEqual(textinput._cursor_position, 26) self.assertEqual(textinput._renderbox, [1, 26, 25]) textinput.update(PygameEventUtils.key(pygame.K_BACKSPACE, keydown=True)) self.assertEqual(textinput._cursor_position, 25) self.assertEqual(textinput._renderbox, [0, 25, 25]) textinput.update( PygameEventUtils.key(pygame.K_a, keydown=True, char='a')) self.assertEqual(textinput._cursor_position, 26) self.assertEqual(textinput._renderbox, [1, 26, 25]) textinput.update(PygameEventUtils.key(pygame.K_BACKSPACE, keydown=True)) self.assertEqual(textinput._cursor_position, 25) self.assertEqual(textinput._renderbox, [0, 25, 25])
def test_config(self) -> None: """ Configure controls. """ self.assertEqual(ctrl.KEY_APPLY, K_RETURN) # Change apply to new key ctrl.KEY_APPLY = K_END self.assertEqual(ctrl.KEY_APPLY, K_END) # Create new button menu = MenuUtils.generic_menu() test = [False] def click_button() -> None: """ Button apply handler. """ test[0] = not test[0] print('new test value', test) button = menu.add.button('button', click_button) self.assertFalse(test[0]) button.apply() self.assertTrue(test[0]) button.apply() self.assertFalse(test[0]) # Now test new apply button button.update(PygameEventUtils.key(K_END, keydown=True)) self.assertTrue(test[0]) # Rollback change ctrl.KEY_APPLY = K_RETURN button.update(PygameEventUtils.key(K_END, keydown=True)) self.assertTrue(test[0]) button.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertFalse(test[0])
def test_invalid_range(self) -> None: """ Test invalid ranges. #356 """ menu = MenuUtils.generic_menu() r = menu.add.range_slider('Infection Rate', default=2, increment=0.5, range_values=(2, 10)) self.assertEqual(r.get_value(), 2) self.assertTrue( r.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True))) self.assertEqual(r.get_value(), 2.5) self.assertTrue( r.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True))) self.assertEqual(r.get_value(), 2) self.assertFalse( r.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True))) self.assertEqual(r.get_value(), 2) for _ in range(20): r.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) self.assertEqual(r.get_value(), 10)
def test_example_timer_clock() -> None: """ Test timer clock example. """ pygame.event.post( PygameEventUtils.keydown(pygame.K_ESCAPE, inlist=False)) timer_clock.main(test=True) timer_clock.mainmenu_background() timer_clock.reset_timer() timer_clock.TestCallClassMethod.update_game_settings() color = (-1, -1, -1) timer_clock.change_color_bg(( color, 'random', ), color, write_on_console=True)
def test_non_ascii(self) -> None: """ Test non-ascii. """ menu = MenuUtils.generic_menu() m = MenuUtils.generic_menu(title=u'Ménu') m.clear() menu.add.button('0', pygame_menu.events.NONE) menu.add.button('Test', pygame_menu.events.NONE) menu.add.button(u'Menú', pygame_menu.events.NONE) menu.add.color_input(u'Cólor', 'rgb') text = menu.add.text_input(u'Téxt') menu.add.label(u'Téxt') menu.add.selector(u'Sélect'.encode('latin1'), [('a', 'a')]) menu.enable() menu.draw(surface) # Text text input text.set_value('ą, ę, ś, ć, ż, ź, ó, ł, ń') self.assertEqual(text.get_value(), 'ą, ę, ś, ć, ż, ź, ó, ł, ń') text.set_value('') text.update(PygameEventUtils.key(pygame.K_l, char='ł', keydown=True)) self.assertEqual(text.get_value(), 'ł')
def test_toggleswitch(self) -> None: """ Test toggleswitch widget. """ menu = MenuUtils.generic_menu() value = [None] def onchange(val) -> None: """ Function executed by toggle. """ value[0] = val switch = menu.add.toggle_switch('toggle', False, onchange=onchange, infinite=False, single_click=False) self.assertFalse(switch.get_value()) self.assertIsNone(value[0]) switch.apply() self.assertFalse(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) # not infinite self.assertFalse(value[0]) # as this is false, dont change switch.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) self.assertTrue(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertFalse(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertFalse(value[0]) self.assertFalse( switch.update( PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True, testmode=False))) switch = menu.add.toggle_switch('toggle', False, onchange=onchange, infinite=True, single_click=False) switch.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertTrue(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertFalse(value[0]) # As there's only 2 states, return should change too switch.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertTrue(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertFalse(value[0]) # Check left/right clicks click_pos = switch.get_rect(to_real_position=True, apply_padding=False).midleft switch.update( PygameEventUtils.mouse_click(click_pos[0] + 150, click_pos[1])) self.assertFalse(value[0]) switch.update( PygameEventUtils.mouse_click(click_pos[0] + 250, click_pos[1])) self.assertTrue(value[0]) switch.update( PygameEventUtils.mouse_click(click_pos[0] + 150, click_pos[1])) self.assertFalse(value[0]) # Test left/right touch switch._touchscreen_enabled = True switch.update( PygameEventUtils.touch_click(click_pos[0] + 250, click_pos[1], menu=switch.get_menu())) self.assertTrue(value[0]) switch.update( PygameEventUtils.touch_click(click_pos[0] + 250, click_pos[1], menu=switch.get_menu())) self.assertTrue(value[0]) switch.update( PygameEventUtils.touch_click(click_pos[0] + 150, click_pos[1], menu=switch.get_menu())) self.assertFalse(value[0]) # Test readonly switch.readonly = True switch.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertFalse(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertFalse(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertFalse(value[0]) switch._left() self.assertFalse(value[0]) switch._right() self.assertFalse(value[0]) switch.readonly = False switch.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) self.assertTrue(value[0]) switch.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) self.assertFalse(value[0]) switch.draw(surface) # Test transforms switch.set_position(1, 1) self.assertEqual(switch.get_position(), (1, 1)) switch.translate(1, 1) self.assertEqual(switch.get_translate(), (1, 1)) self.assertRaises(WidgetTransformationNotImplemented, lambda: switch.rotate(10)) self.assertEqual(switch._angle, 0) self.assertRaises(WidgetTransformationNotImplemented, lambda: switch.scale(100, 100)) self.assertFalse(switch._scale[0]) self.assertEqual(switch._scale[1], 1) self.assertEqual(switch._scale[2], 1) self.assertRaises(WidgetTransformationNotImplemented, lambda: switch.resize(100, 100)) self.assertFalse(switch._scale[0]) self.assertEqual(switch._scale[1], 1) self.assertEqual(switch._scale[2], 1) self.assertRaises(WidgetTransformationNotImplemented, lambda: switch.flip(True, True)) self.assertFalse(switch._flip[0]) self.assertFalse(switch._flip[1]) self.assertRaises(WidgetTransformationNotImplemented, lambda: switch.set_max_width(100)) self.assertIsNone(switch._max_width[0]) self.assertRaises(WidgetTransformationNotImplemented, lambda: switch.set_max_height(100)) self.assertIsNone(switch._max_height[0]) # Assert switch values self.assertRaises( ValueError, lambda: menu.add.toggle_switch( 'toggle', 'false', onchange=onchange, infinite=False)) # Test single click toggle switch_single = menu.add.toggle_switch('toggle', False, onchange=onchange) self.assertTrue(switch_single._infinite ) # Infinite sets to True if using single click self.assertFalse(switch_single.get_value()) switch_single._left() self.assertTrue(switch_single.get_value()) click_pos = switch_single.get_rect(to_real_position=True, apply_padding=False).midleft # Test single click toggle between two states switch_single.update( PygameEventUtils.mouse_click(click_pos[0] + 150, click_pos[1])) self.assertFalse( switch_single.get_value()) # single_click_dir=True, move to left switch_single.update( PygameEventUtils.mouse_click(click_pos[0] + 250, click_pos[1])) self.assertTrue(switch_single.get_value()) switch_single.update( PygameEventUtils.mouse_click(click_pos[0] + 250, click_pos[1])) self.assertFalse(switch_single.get_value()) switch_single._single_click_dir = False switch_single.update( PygameEventUtils.mouse_click(click_pos[0] + 250, click_pos[1])) self.assertTrue(switch_single.get_value()) # Create invalid single click params self.assertRaises( AssertionError, lambda: menu.add.toggle_switch( 'toggle', False, single_click='true')) self.assertRaises( AssertionError, lambda: menu.add.toggle_switch( 'toggle', False, single_click_dir='true')) # Test other constructor params pygame_menu.widgets.ToggleSwitch( 'Epic', state_text_font=menu._theme.widget_font) self.assertRaises( AssertionError, lambda: pygame_menu.widgets.ToggleSwitch('Epic', state_text_font_size=-1))
def test_scrollbar(self) -> None: """ Test ScrollBar widget. """ screen_size = surface.get_size() world = pygame.Surface((WINDOW_SIZE[0] * 2, WINDOW_SIZE[1] * 3)) world.fill((200, 200, 200)) for x in range(100, world.get_width(), 200): for y in range(100, world.get_height(), 200): pygame.draw.circle(world, (225, 34, 43), (x, y), 100, 10) # Vertical right scrollbar thick = 80 length = screen_size[1] world_range = (50, world.get_height()) x, y = screen_size[0] - thick, 0 sb = ScrollBar( length, world_range, 'sb2', ORIENTATION_VERTICAL, slider_pad=2, slider_color=(210, 120, 200), page_ctrl_thick=thick, page_ctrl_color=(235, 235, 230) ) self.assertEqual(sb.get_thickness(), 80) self.assertIsNone(sb.get_scrollarea()) sb.set_shadow(color=(245, 245, 245), position=POSITION_SOUTHEAST) self.assertFalse(sb._font_shadow) sb.set_position(x, y) self.assertEqual(sb._orientation, 1) self.assertEqual(sb.get_orientation(), ORIENTATION_VERTICAL) self.assertEqual(sb.get_minimum(), world_range[0]) self.assertEqual(sb.get_maximum(), world_range[1]) sb.set_value(80) self.assertAlmostEqual(sb.get_value(), 80, delta=2) # Scaling delta sb.update(PygameEventUtils.mouse_click(x + thick / 2, y + 2, evtype=pygame.MOUSEBUTTONDOWN)) self.assertEqual(sb.get_value(), 50) self.assertEqual(sb.get_value_percentage(), 0) sb.set_page_step(length) self.assertAlmostEqual(sb.get_page_step(), length, delta=2) # Scaling delta sb.draw(surface) # Test events sb.update(PygameEventUtils.key(pygame.K_PAGEDOWN, keydown=True)) self.assertEqual(sb.get_value(), 964) sb.update(PygameEventUtils.key(pygame.K_PAGEUP, keydown=True)) self.assertEqual(sb.get_value(), 50) self.assertEqual(sb._last_mouse_pos, (-1, -1)) sb.update(PygameEventUtils.enter_window()) self.assertEqual(sb._last_mouse_pos, (-1, -1)) sb.update(PygameEventUtils.leave_window()) self.assertEqual(sb._last_mouse_pos, pygame.mouse.get_pos()) self.assertFalse(sb.scrolling) sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), evtype=pygame.MOUSEBUTTONDOWN)) self.assertTrue(sb.scrolling) sb.update(PygameEventUtils.mouse_click(1, 1)) self.assertFalse(sb.scrolling) self.assertEqual(sb.get_value(), 50) sb.update(PygameEventUtils.middle_rect_click(sb.get_rect(to_absolute_position=True), evtype=pygame.MOUSEBUTTONDOWN)) self.assertEqual(sb.get_value(), 964) sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), evtype=pygame.MOUSEBUTTONDOWN)) self.assertTrue(sb.scrolling) sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), button=4, evtype=pygame.MOUSEBUTTONDOWN)) self.assertEqual(sb.get_value(), 875) sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), button=5, evtype=pygame.MOUSEBUTTONDOWN)) self.assertEqual(sb.get_value(), 964) self.assertEqual(sb.get_value_percentage(), 0.522) # Test mouse motion while scrolling sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), button=5, delta=(0, 50), rel=(0, 10), evtype=pygame.MOUSEMOTION)) self.assertEqual(sb.get_value_percentage(), 0.547) sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), button=5, delta=(0, 50), rel=(0, -10), evtype=pygame.MOUSEMOTION)) self.assertEqual(sb.get_value_percentage(), 0.522) sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), button=5, delta=(0, 50), rel=(0, 999), evtype=pygame.MOUSEMOTION)) self.assertEqual(sb.get_value_percentage(), 1) sb.readonly = True self.assertFalse(sb.update([])) # Ignore events if mouse outside the region sb.update(PygameEventUtils.middle_rect_click(sb.get_slider_rect(), button=5, delta=(0, 999), rel=(0, -10), evtype=pygame.MOUSEMOTION)) self.assertIn(sb.get_value_percentage(), (0.976, 1)) # Test remove onreturn sb = ScrollBar(length, world_range, 'sb', ORIENTATION_VERTICAL, onreturn=-1) self.assertIsNone(sb._onreturn) self.assertTrue(sb._kwargs.get('onreturn', 0)) # Scrollbar ignores scaling self.assertRaises(WidgetTransformationNotImplemented, lambda: sb.scale(2, 2)) self.assertFalse(sb._scale[0]) self.assertRaises(WidgetTransformationNotImplemented, lambda: sb.resize(2, 2)) self.assertFalse(sb._scale[0]) self.assertRaises(WidgetTransformationNotImplemented, lambda: sb.set_max_width(10)) self.assertIsNone(sb._max_width[0]) self.assertRaises(WidgetTransformationNotImplemented, lambda: sb.set_max_height(10)) self.assertIsNone(sb._max_height[0]) sb._apply_font() sb.set_padding(10) self.assertEqual(sb._padding[0], 0) self.assertRaises(WidgetTransformationNotImplemented, lambda: sb.rotate(10)) self.assertEqual(sb._angle, 0) self.assertRaises(WidgetTransformationNotImplemented, lambda: sb.flip(True, True)) self.assertFalse(sb._flip[0]) self.assertFalse(sb._flip[1]) # Set minimum sb.set_minimum(0.5 * sb._values_range[1]) # Test hide sb._mouseover = True sb.hide()
def test_single_rangeslider(self) -> None: """ Test single range slider. """ menu = MenuUtils.generic_menu() # Single slider slider = pygame_menu.widgets.RangeSlider('Range S') test = [0, 0] def onchange(x: float) -> None: """ Change slider. """ # noinspection PyTypeChecker test[0] = x def onreturn(x: float) -> None: """ Return slider. """ # noinspection PyTypeChecker test[1] = x slider.set_onchange(onchange) slider.set_onreturn(onreturn) menu.add.generic_widget(slider, True) self.assertEqual(slider.get_value(), 0) slider.set_value(0.5) self.assertEqual(slider.get_value(), 0.5) self.assertEqual(slider._value, [0.5, 0]) self.assertEqual(test[0], 0) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(test[0], 0.4) self.assertEqual(slider.get_value(), 0.4) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertAlmostEqual(slider.get_value(), 0.3) for _ in range(10): slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(slider.get_value(), 0) self.assertTrue( slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True))) self.assertEqual(slider.get_value(), 0.1) self.assertEqual(test[1], 0) slider.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertEqual(test[1], 0.1) # Ignore invalid key self.assertFalse( slider.update( PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True, testmode=False))) # Ignore for readonly slider.draw(surface) slider.draw_after_if_selected(surface) slider.readonly = True self.assertFalse( slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True))) self.assertEqual(slider.get_value(), 0.1) slider._update_value(0) self.assertEqual(slider.get_value(), 0.1) slider.readonly = False # Test invalid values self.assertRaises(AssertionError, lambda: slider.set_value(-1)) self.assertRaises(AssertionError, lambda: slider.set_value([0.4, 0.5])) # Test invalid transforms self.assertRaises(WidgetTransformationNotImplemented, lambda: slider.rotate()) self.assertRaises(WidgetTransformationNotImplemented, lambda: slider.flip()) self.assertRaises(WidgetTransformationNotImplemented, lambda: slider.scale()) self.assertRaises(WidgetTransformationNotImplemented, lambda: slider.resize()) self.assertRaises(WidgetTransformationNotImplemented, lambda: slider.set_max_width()) self.assertRaises(WidgetTransformationNotImplemented, lambda: slider.set_max_height()) # Test mouse click self.assertFalse(slider._selected_mouse) pos = slider._test_get_pos_value(0.5) slider.update( PygameEventUtils.middle_rect_click(pos, evtype=pygame.MOUSEBUTTONDOWN)) self.assertEqual(slider.get_value(), 0.1) self.assertTrue(slider._selected_mouse) self.assertFalse(slider._scrolling) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertFalse(slider._scrolling) self.assertEqual(slider.get_value(), 0.5) self.assertFalse(slider._selected_mouse) # Mouse click out of range slider._selected_mouse = True pos = slider._test_get_pos_value(1, dx=100) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertEqual(slider.get_value(), 0.5) self.assertFalse(slider._selected_mouse) slider._selected_mouse = True pos = slider._test_get_pos_value(0, dx=-100) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertEqual(slider.get_value(), 0.5) self.assertFalse(slider._selected_mouse) # Test extremes slider._selected_mouse = True pos = slider._test_get_pos_value(0) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertEqual(slider.get_value(), 0) slider._selected_mouse = True pos = slider._test_get_pos_value(1) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertEqual(slider.get_value(), 1) # Scroll to 0.5 pos2 = slider._test_get_pos_value(0.5) self.assertFalse(slider._scrolling) slider_rect = slider._get_slider_inflate_rect(0, to_real_position=True) slider.update( PygameEventUtils.middle_rect_click(slider_rect, evtype=pygame.MOUSEBUTTONDOWN)) self.assertTrue(slider._scrolling) self.assertTrue(slider._selected_mouse) dx = pos[0] - pos2[0] slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-dx, pos[1]), update_mouse=True)) self.assertEqual(slider.get_value(), 0.5) self.assertTrue(slider._scrolling) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertFalse(slider._scrolling) # Check invalid constructor for single slider self.assertRaises( AssertionError, lambda: pygame_menu.widgets.RangeSlider( 'Range S', default_value=2)) self.assertRaises( AssertionError, lambda: pygame_menu.widgets.RangeSlider( 'Range S', default_value=1, range_values=[1, 0])) self.assertRaises( AssertionError, lambda: pygame_menu.widgets.RangeSlider( 'Range S', default_value=1, range_values=[1, 1])) self.assertRaises( AssertionError, lambda: pygame_menu.widgets.RangeSlider('Range S', default_value='a')) # Ignore tabs self.assertFalse( slider.update(PygameEventUtils.key(ctrl.KEY_TAB, keydown=True))) # Check LEFT key in repeat self.assertIn(ctrl.KEY_RIGHT, slider._keyrepeat_counters.keys()) self.assertEqual(slider.get_value(), 0.5) # Make left repeat slider._keyrepeat_counters[ctrl.KEY_RIGHT] += 1e4 self.assertEqual(len(slider._events), 0) self.assertFalse(slider.update([])) self.assertEqual(len(slider._events), 1) self.assertFalse(slider.update( [])) # As key is not pressed, event continues self.assertEqual(len(slider._events), 0) # Keyup, removes counters slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keyup=True)) self.assertNotIn(ctrl.KEY_RIGHT, slider._keyrepeat_counters.keys()) self.assertFalse(hasattr(slider, '_range_box')) # Single slider with range box slider_rb = pygame_menu.widgets.RangeSlider( 'Range', range_box_single_slider=True) menu.add.generic_widget(slider_rb, True) slider_rb.draw(surface) self.assertTrue(hasattr(slider_rb, '_range_box')) self.assertEqual(slider_rb._range_box.get_width(), 0) slider_rb.set_value(1) self.assertEqual(slider_rb._range_box.get_width(), 150)
def test_unicode(self) -> None: """ Test unicode support. """ menu = MenuUtils.generic_menu() textinput = menu.add.text_input('title', input_underline='_') textinput.set_value('tk') # Test alt+x textinput.update(PygameEventUtils.key(pygame.K_SPACE, keydown=True)) textinput.update( PygameEventUtils.key(pygame.K_2, keydown=True, char='2')) textinput.update( PygameEventUtils.key(pygame.K_1, keydown=True, char='1')) textinput.update( PygameEventUtils.key(pygame.K_1, keydown=True, char='5')) self.assertEqual(textinput.get_value(), 'tk 215') textinput.update(PygameEventUtils.keydown_mod_alt( pygame.K_x)) # convert 215 to unicode self.assertEqual(textinput.get_value(), 'tkȕ') textinput.update(PygameEventUtils.key(pygame.K_SPACE, keydown=True)) textinput.update(PygameEventUtils.key(pygame.K_SPACE, keydown=True)) textinput.update( PygameEventUtils.key(pygame.K_b, keydown=True, char='B')) textinput.update( PygameEventUtils.key(pygame.K_1, keydown=True, char='1')) textinput.update(PygameEventUtils.keydown_mod_alt( pygame.K_x)) # convert 215 to unicode self.assertEqual(textinput.get_value(), 'tkȕ ±') # Remove all textinput.clear() textinput.update( PygameEventUtils.key(pygame.K_b, keydown=True, char='B')) textinput.update( PygameEventUtils.key(pygame.K_1, keydown=True, char='1')) textinput.update(PygameEventUtils.keydown_mod_alt( pygame.K_x)) # convert 215 to unicode self.assertEqual(textinput.get_value(), '±') textinput.update(PygameEventUtils.keydown_mod_alt( pygame.K_x)) # convert same to unicode, do nothing self.assertEqual(textinput.get_value(), '±') # Test consecutive textinput.update( PygameEventUtils.key(pygame.K_2, keydown=True, char='2')) textinput.update( PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) textinput.update( PygameEventUtils.key(pygame.K_1, keydown=True, char='1')) textinput.update( PygameEventUtils.key(pygame.K_3, keydown=True, char='3')) textinput.update(PygameEventUtils.keydown_mod_alt( pygame.K_x)) # convert 215 to unicode self.assertEqual(textinput.get_value(), '±–') # Test 0x textinput.clear() PygameEventUtils.release_key_mod() textinput.update( PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) self.assertEqual(textinput.get_value(), '0') textinput.update( PygameEventUtils.key(pygame.K_x, keydown=True, char='x')) self.assertEqual(textinput.get_value(), '0x') textinput.update(PygameEventUtils.keydown_mod_alt(pygame.K_x)) self.assertEqual(textinput.get_value(), '0x') textinput.update( PygameEventUtils.key(pygame.K_b, keydown=True, char='B')) textinput.update( PygameEventUtils.key(pygame.K_1, keydown=True, char='1')) self.assertEqual(textinput.get_value(), '0xB1') textinput.update(PygameEventUtils.keydown_mod_alt(pygame.K_x)) self.assertEqual(textinput.get_value(), '±') PygameEventUtils.release_key_mod() textinput.update( PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) textinput.update( PygameEventUtils.key(pygame.K_x, keydown=True, char='x')) textinput.update( PygameEventUtils.key(pygame.K_b, keydown=True, char='B')) textinput.update( PygameEventUtils.key(pygame.K_1, keydown=True, char='1')) textinput.update(PygameEventUtils.keydown_mod_alt(pygame.K_x)) self.assertEqual(textinput.get_value(), '±±') # Test keyup self.assertIn(pygame.K_1, textinput._keyrepeat_counters.keys()) self.assertFalse( textinput.update( PygameEventUtils.key(pygame.K_1, keyup=True, char='1'))) self.assertNotIn(pygame.K_1, textinput._keyrepeat_counters.keys()) # Test tab self.assertEqual(textinput._tab_size, 4) textinput.update(PygameEventUtils.key(pygame.K_TAB, keydown=True)) self.assertEqual(textinput.get_value(), '±± ') # Test invalid unicode self.assertFalse( textinput.update(PygameEventUtils.key(pygame.K_1, keydown=True))) # Test others textinput._input_type = 'other' self.assertTrue(textinput._check_input_type('-')) self.assertFalse(textinput._check_input_type('x')) textinput._maxwidth_update = None self.assertIsNone(textinput._update_maxlimit_renderbox())
def test_size(self) -> None: """ Test size. """ if SYS_PLATFORM_OSX: return menu = MenuUtils.generic_menu(title='menu', theme=TEST_THEME.copy()) menu.render() self.assertEqual(menu.get_height(widget=True), 0) # Adds a button, hide it, then the height should be 0 as well btn = menu.add.button('hidden') btn.hide() self.assertEqual(menu.get_height(widget=True), 0) menu.render() # Get the size of the scrollarea sa = menu.get_scrollarea() sa_height = menu.get_height() - menu.get_menubar().get_height() sa_width = menu.get_width() self.assertEqual(sa.get_world_size()[0], sa_width) self.assertEqual(sa.get_world_size()[1], sa_height) rect = sa.get_view_rect() self.assertEqual(rect.x, 0) self.assertEqual(rect.y, 155) self.assertEqual(rect.width, sa_width) self.assertEqual(rect.height, sa_height) self.assertEqual(sa.get_hidden_width(), 0) self.assertEqual(sa.get_hidden_height(), 0) rect = sa.to_world_position(btn.get_rect()) self.assertEqual(rect.x, 0) self.assertEqual(rect.y, -155) self.assertEqual(rect.width, btn.get_width()) self.assertEqual(rect.height, btn.get_height()) pos_rect = sa.to_world_position((10, 10)) self.assertEqual(pos_rect, (10, -145)) self.assertFalse(sa.is_scrolling()) self.assertEqual(sa.get_menu(), menu) sa._on_vertical_scroll(50) sa._on_horizontal_scroll(50) # Remove the world of surface world = sa._world sa._world = None self.assertEqual(sa.get_world_size(), (0, 0)) sa._world = world # Test collide event = PygameEventUtils.mouse_click(100, 100, inlist=False) self.assertFalse(sa.collide(btn, event)) # Create virtual rect from button rect_virtual = sa.to_real_position(btn.get_rect()) event_click_widget = PygameEventUtils.middle_rect_click(rect_virtual, inlist=False) self.assertTrue(sa.collide(btn, event_click_widget)) self.assertEqual(sa.get_world_rect(absolute=True), pygame.Rect(0, 0, 600, 345)) self.assertEqual(sa.get_size(), (600, 345)) self.assertIsInstance(sa.mouse_is_over(), bool) # Append many items within menu, thus, scrollbars will appear self.assertEqual(sa.get_scrollbar_thickness(ORIENTATION_VERTICAL), 0) self.assertEqual(sa.get_scrollbar_thickness(ORIENTATION_HORIZONTAL), 0) sa._scrollbar_positions = (POSITION_NORTH, POSITION_EAST, POSITION_WEST, POSITION_SOUTH) self.assertEqual(sa.get_view_rect(), pygame.Rect(0, 155, 600, 345)) for i in range(10): menu.add.button('b{0}'.format(i)).scale(20, 1) self.assertEqual(sa.get_scrollbar_thickness(ORIENTATION_VERTICAL), 20) self.assertEqual(sa.get_scrollbar_thickness(ORIENTATION_HORIZONTAL), 20) sa._on_vertical_scroll(0.5) sa._on_horizontal_scroll(0.5) self.assertEqual(sa.to_real_position((10, 10)), (10, 165)) sa.get_view_rect() # Test rect sa = pygame_menu._scrollarea.ScrollArea(100, 100) self.assertEqual(sa.get_rect(to_real_position=True), pygame.Rect(0, 0, 100, 100)) self.assertEqual(sa.get_scrollbar_thickness(ORIENTATION_VERTICAL, visible=False), 0) self.assertEqual(sa.get_scrollbar_thickness(ORIENTATION_HORIZONTAL, visible=False), 0) self.assertEqual(sa.get_scrollbar_thickness(ORIENTATION_VERTICAL, visible=False), 0) self.assertRaises(AssertionError, lambda: sa.get_scrollbar_thickness('fake', visible=False))
def test_dropselect_multiple(self) -> None: """ Test dropselect multiple widget. """ theme = pygame_menu.themes.THEME_DEFAULT.copy() theme.widget_font_size = 25 menu = MenuUtils.generic_menu(mouse_motion_selection=True, theme=theme) items = [('This is a really long selection item', 1), ('epic', 2)] for i in range(10): items.append(('item{}'.format(i + 1), i + 1)) # noinspection SpellCheckingInspection drop = pygame_menu.widgets.DropSelectMultiple('dropsel', items, open_middle=True, selection_box_height=5) self.assertNotEqual(id(items), id(drop._items)) menu.add.generic_widget(drop, configure_defaults=True) self.assertEqual(drop._selection_box_width, 225 if not SYS_PLATFORM_OSX else 226) # Check drop is empty self.assertEqual(drop.get_value(), ([], [])) self.assertEqual(drop.get_index(), []) self.assertEqual(drop._get_current_selected_text(), 'Select an option') # Check events self.assertFalse(drop.active) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertTrue(drop.active) self.assertEqual(drop._index, -1) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) # Index is -1 self.assertFalse(drop.active) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertTrue(drop.active) drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) self.assertEqual(drop._index, 0) drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) self.assertEqual(drop._index, 1) # Apply on current drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertEqual(drop.get_value(), ([('epic', 2)], [1])) self.assertEqual(drop.get_index(), [1]) self.assertEqual(drop._get_current_selected_text(), '1 selected') drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertEqual(drop.get_value(), ([('epic', 2), ('item2', 2)], [1, 3])) self.assertEqual(drop._get_current_selected_text(), '2 selected') # Change selection type drop._selection_placeholder_format = DROPSELECT_MULTIPLE_SFORMAT_LIST_COMMA self.assertEqual(drop._get_current_selected_text(), 'epic,item2 selected') drop._selection_placeholder_format = DROPSELECT_MULTIPLE_SFORMAT_LIST_HYPHEN self.assertEqual(drop._get_current_selected_text(), 'epic-item2 selected') drop._selection_placeholder_format = '+' self.assertEqual(drop._get_current_selected_text(), 'epic+item2 selected') def format_string_list(items_list) -> str: """ Receives the items list string and returns a function. :param items_list: Items list :return: Join string """ if len(items_list) == 1: return items_list[0] elif len(items_list) == 2: return items_list[0] + ' and ' + items_list[1] return 'overflow' drop._selection_placeholder_format = format_string_list self.assertEqual(drop._get_current_selected_text(), 'epic and item2 selected') # Invalid format drop._selection_placeholder_format = 1 self.assertRaises(ValueError, lambda: drop._get_current_selected_text()) drop._selection_placeholder_format = lambda: print('nice') self.assertRaises(ValueError, lambda: drop._get_current_selected_text()) drop._selection_placeholder_format = lambda x: 1 self.assertRaises(AssertionError, lambda: drop._get_current_selected_text()) # Back to default drop._selection_placeholder_format = DROPSELECT_MULTIPLE_SFORMAT_TOTAL # Click item 2, this should unselect self.assertTrue(drop.active) drop.update(PygameEventUtils.middle_rect_click( drop._option_buttons[3])) self.assertEqual(drop.get_value(), ([('epic', 2)], [1])) self.assertEqual(drop._get_current_selected_text(), '1 selected') drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) self.assertEqual(drop._index, 4) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertEqual(drop.get_value(), ([('epic', 2), ('item3', 3)], [1, 4])) self.assertEqual(drop._get_current_selected_text(), '2 selected') # Close drop.update(PygameEventUtils.key(pygame.K_ESCAPE, keydown=True)) self.assertFalse(drop.active) self.assertEqual(drop.get_value(), ([('epic', 2), ('item3', 3)], [1, 4])) self.assertEqual(drop._get_current_selected_text(), '2 selected') # Change drop selected text method # Set max limit drop._max_selected = 3 self.assertEqual(drop.get_total_selected(), 2) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertEqual(drop.get_total_selected(), 3) self.assertTrue(drop.active) drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertEqual(drop.get_total_selected(), 3) # Limit reached self.assertEqual(drop.get_value(), ([('epic', 2), ('item3', 3), ('item4', 4)], [1, 4, 5])) drop.update(PygameEventUtils.key(ctrl.KEY_MOVE_DOWN, keydown=True)) drop.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) # Unselect previous self.assertEqual(drop.get_total_selected(), 2) # Limit reached self.assertEqual(drop.get_value(), ([('epic', 2), ('item3', 3)], [1, 4])) # Update elements drop.update_items([('This is a really long selection item', 1), ('epic', 2)]) self.assertEqual(drop.get_value(), ([], [])) self.assertEqual(drop._get_current_selected_text(), 'Select an option') drop.set_value(1, process_index=True) self.assertEqual(drop.get_value(), ([('epic', 2)], [1])) drop.set_value('This is a really long selection item', process_index=True) self.assertEqual(drop.get_value(), ([('This is a really long selection item', 1), ('epic', 2)], [0, 1])) self.assertEqual(drop._get_current_selected_text(), '2 selected') drop.set_default_value(1) self.assertEqual(drop.get_value(), ([('epic', 2)], [1])) self.assertEqual(drop._get_current_selected_text(), '1 selected') # Use manager drop2 = menu.add.dropselect_multiple( 'nice', [('This is a really long selection item', 1), ('epic', 2)], placeholder_selected='nice {0}', placeholder='epic', max_selected=1) self.assertEqual(drop2._selection_box_width, 134 if not SYS_PLATFORM_OSX else 135) self.assertEqual(drop2._get_current_selected_text(), 'epic') drop2.set_value('epic', process_index=True) self.assertEqual(drop2.get_index(), [1]) self.assertEqual(drop2._get_current_selected_text(), 'nice 1') drop2.set_value(0, process_index=True) self.assertEqual(drop2.get_index(), [1]) self.assertEqual(drop2._get_current_selected_text(), 'nice 1') self.assertEqual(drop2._default_value, []) self.assertEqual(drop2._index, 0) self.assertRaises(ValueError, lambda: drop2.set_value('not epic')) # Reset drop2.reset_value() self.assertEqual(drop2._get_current_selected_text(), 'epic') self.assertEqual(drop2._default_value, []) self.assertEqual(drop2._index, -1) self.assertEqual(drop2.get_index(), []) self.assertNotEqual(id(drop2._default_value), id(drop2._selected_indices)) menu.select_widget(drop2) self.assertTrue( drop2.update(PygameEventUtils.key(pygame.K_TAB, keydown=True))) # Test hide self.assertTrue(drop2._drop_frame.is_visible()) self.assertTrue(drop2.active) drop2.hide() # Hiding selects the other widget self.assertEqual(menu.get_selected_widget(), drop) self.assertFalse(drop2._drop_frame.is_visible()) self.assertFalse(drop2.active) drop2.show() self.assertFalse(drop2._drop_frame.is_visible()) self.assertFalse(drop2.active) self.assertEqual(menu.get_selected_widget(), drop) menu.select_widget(drop2) drop2._toggle_drop() self.assertTrue(drop2.active) self.assertTrue(drop2._drop_frame.is_visible()) # Test change test = [-1] def onchange(value) -> None: """ Test onchange. """ test[0] = value[1] drop2.set_onchange(onchange) # Pick any option menu.render() self.assertEqual(test, [-1]) drop2._option_buttons[0].apply() self.assertEqual(test[0], [0]) drop2._option_buttons[0].apply() self.assertEqual(test[0], []) drop2._option_buttons[0].apply() drop2._option_buttons[1].apply() self.assertEqual(test[0], [0]) # As max selected is only 1 drop2._max_selected = 2 drop2._option_buttons[1].apply() self.assertEqual(test[0], [0, 1]) # Test none drop frame drop2._drop_frame = None self.assertEqual(drop2.get_scroll_value_percentage('any'), -1) # Test format option from manager menu._theme.widget_background_inflate_to_selection = True menu._theme.widget_background_inflate = 0 # menu._theme.widget_border_inflate = 0 menu._theme.widget_margin = 0 drop2 = menu.add.dropselect_multiple( 'nice', [('This is a really long selection item', 1), ('epic', 2)], placeholder_selected='nice {0}', placeholder='epic', max_selected=1, selection_placeholder_format=lambda x: 'not EPIC') self.assertEqual(drop2._get_current_selected_text(), 'epic') drop2.set_value('epic', process_index=True) self.assertEqual(drop2._get_current_selected_text(), 'nice not EPIC') self.assertEqual(drop2.get_margin(), (0, 0)) self.assertEqual(drop2._background_inflate, (0, 0)) self.assertEqual(drop2._border_inflate, (0, 0)) menu._theme.widget_background_inflate_to_selection = False # Process index drop2._index = -1 drop2._process_index()
def test_single_discrete(self) -> None: """ Test single range slider with discrete values. """ menu = MenuUtils.generic_menu() # Single slider with discrete values rv = [0, 1, 2, 3, 4, 5] slider = pygame_menu.widgets.RangeSlider('Range', range_values=rv) menu.add.generic_widget(slider, True) self.assertRaises( AssertionError, lambda: pygame_menu.widgets.RangeSlider( 'Range', default_value=0.5, range_values=rv)) self.assertRaises( AssertionError, lambda: pygame_menu.widgets.RangeSlider( 'Range', default_value=-1, range_values=rv)) self.assertRaises(AssertionError, lambda: slider.set_value(-1)) self.assertRaises(AssertionError, lambda: slider.set_value([0, 1])) self.assertRaises(AssertionError, lambda: slider.set_value((0, 1))) # Test key events self.assertFalse( slider.update(PygameEventUtils.key(ctrl.KEY_TAB, keydown=True))) slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) self.assertEqual(slider.get_value(), 1) slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) self.assertEqual(slider.get_value(), 2) slider._increment = 0 slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) self.assertEqual(slider.get_value(), 3) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(slider.get_value(), 2) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(slider.get_value(), 1) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(slider.get_value(), 0) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(slider.get_value(), 0) # Test click mouse slider._selected_mouse = True pos = slider._test_get_pos_value(2) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertEqual(slider.get_value(), 2) self.assertFalse(slider._selected_mouse) # Test invalid click slider._selected_mouse = True pos = slider._test_get_pos_value(2, dx=1000) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertEqual(slider.get_value(), 2) self.assertFalse(slider._selected_mouse) # Scroll to 4 pos = slider._test_get_pos_value(2) pos2 = slider._test_get_pos_value(4) self.assertFalse(slider._scrolling) slider_rect = slider._get_slider_inflate_rect(0, to_real_position=True) slider.update( PygameEventUtils.middle_rect_click(slider_rect, evtype=pygame.MOUSEBUTTONDOWN)) self.assertTrue(slider._scrolling) self.assertTrue(slider._selected_mouse) dx = pos[0] - pos2[0] slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-dx, pos[1]), update_mouse=True)) self.assertEqual(slider.get_value(), 4) self.assertTrue(slider._scrolling) slider.update(PygameEventUtils.middle_rect_click(pos)) self.assertFalse(slider._scrolling) # Back to 2 slider.set_value(2) # Invalid scrolling if clicked outside the slider slider.update( PygameEventUtils.middle_rect_click(slider._test_get_pos_value(0), evtype=pygame.MOUSEBUTTONDOWN)) self.assertFalse(slider._scrolling)
def test_menubar(self) -> None: """ Test menubar widget. """ menu = MenuUtils.generic_menu() for mode in (MENUBAR_STYLE_ADAPTIVE, MENUBAR_STYLE_NONE, MENUBAR_STYLE_SIMPLE, MENUBAR_STYLE_UNDERLINE, MENUBAR_STYLE_UNDERLINE_TITLE, MENUBAR_STYLE_TITLE_ONLY, MENUBAR_STYLE_TITLE_ONLY_DIAGONAL): mb = MenuBar('Menu', 500, (0, 0, 0), back_box=True, mode=mode) menu.add.generic_widget(mb) mb = MenuBar('Menu', 500, (0, 0, 0), back_box=True) mb.set_backbox_border_width(2) self.assertRaises(AssertionError, lambda: mb.set_backbox_border_width(1.5)) self.assertRaises(AssertionError, lambda: mb.set_backbox_border_width(0)) self.assertRaises(AssertionError, lambda: mb.set_backbox_border_width(-1)) self.assertEqual(mb._backbox_border_width, 2) menu.draw(surface) menu.disable() # Test unknown mode mb = MenuBar('Menu', 500, (0, 0, 0), back_box=True, mode='unknown') mb.set_menu(menu) self.assertRaises(ValueError, lambda: mb._render()) # Check margins mb = MenuBar('Menu', 500, (0, 0, 0), back_box=True, mode=MENUBAR_STYLE_ADAPTIVE) self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 0))) mb.set_menu(menu) mb._render() self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTHWEST), (0, (0, 0))) # Test displacements theme = pygame_menu.themes.THEME_DEFAULT.copy() theme.title_bar_style = MENUBAR_STYLE_TITLE_ONLY menu = MenuUtils.generic_menu(theme=theme, title='my title') mb = menu.get_menubar() self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (-55, (0, 55))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 55))) # Test with close button menu = MenuUtils.generic_menu(theme=theme, title='my title', onclose=pygame_menu.events.CLOSE, touchscreen=True) theme.widget_border_inflate = 0 mb = menu.get_menubar() self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (-33, (0, 33))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (-55, (0, 55))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 55))) # Hide the title, and check mb.hide() self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 0))) mb.show() self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (-33, (0, 33))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (-55, (0, 55))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 55))) # Floating mb.set_float(True) self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 0))) mb.set_float(False) self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (-33, (0, 33))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (-55, (0, 55))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 55))) # Fixed mb.fixed = False self.assertEqual(mb.get_scrollbar_style_change(POSITION_SOUTH), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_EAST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_WEST), (0, (0, 0))) self.assertEqual(mb.get_scrollbar_style_change(POSITION_NORTH), (0, (0, 0))) # Test menubar self.assertFalse( mb.update(PygameEventUtils.middle_rect_click(mb._rect))) self.assertTrue( mb.update(PygameEventUtils.middle_rect_click(mb._backbox_rect))) self.assertTrue( mb.update( PygameEventUtils.middle_rect_click(mb._backbox_rect, evtype=pygame.FINGERUP, menu=menu))) self.assertFalse( mb.update( PygameEventUtils.middle_rect_click( mb._backbox_rect, evtype=pygame.MOUSEBUTTONDOWN))) self.assertTrue( mb.update(PygameEventUtils.joy_button(ctrl.JOY_BUTTON_BACK))) mb.readonly = True self.assertFalse( mb.update(PygameEventUtils.joy_button(ctrl.JOY_BUTTON_BACK))) mb.readonly = False # Test none methods self.assertRaises(WidgetTransformationNotImplemented, lambda: mb.rotate(10)) self.assertEqual(mb._angle, 0) self.assertRaises(WidgetTransformationNotImplemented, lambda: mb.resize(10, 10)) self.assertFalse(mb._scale[0]) self.assertEqual(mb._scale[1], 1) self.assertEqual(mb._scale[2], 1) self.assertRaises(WidgetTransformationNotImplemented, lambda: mb.scale(100, 100)) self.assertFalse(mb._scale[0]) self.assertEqual(mb._scale[1], 1) self.assertEqual(mb._scale[2], 1) self.assertRaises(WidgetTransformationNotImplemented, lambda: mb.flip(True, True)) self.assertFalse(mb._flip[0]) self.assertFalse(mb._flip[1]) self.assertRaises(WidgetTransformationNotImplemented, lambda: mb.set_max_width(100)) self.assertIsNone(mb._max_width[0]) self.assertRaises(WidgetTransformationNotImplemented, lambda: mb.set_max_height(100)) self.assertIsNone(mb._max_height[0]) # Ignore others mb.set_padding() mb.set_border() mb.set_selection_effect() menu.add.button('nice')
def test_example_other_calculator(self) -> None: """ Test calculator example. """ app = calculator.main(test=True) # Process events app.process_events( PygameEventUtils.keydown([ pygame.K_1, pygame.K_2, pygame.K_3, pygame.K_4, pygame.K_5, pygame.K_PLUS ])) self.assertEqual(app.prev, '12345') self.assertEqual(app.op, '+') app.process_events( PygameEventUtils.keydown( [pygame.K_6, pygame.K_7, pygame.K_8, pygame.K_9, pygame.K_0])) self.assertEqual(app.curr, '67890') app.process_events(PygameEventUtils.keydown(pygame.K_EQUALS)) self.assertEqual(app.op, '') self.assertEqual(app.curr, '80235') self.assertEqual(app.prev, '') app.process_events(PygameEventUtils.keydown([pygame.K_x, pygame.K_2])) self.assertEqual(app.op, 'x') self.assertEqual(app.curr, '2') self.assertEqual(app.prev, '80235') app.process_events(PygameEventUtils.keydown([pygame.K_x])) self.assertEqual(app.op, 'x') self.assertEqual(app.curr, '') self.assertEqual(app.prev, '160470') app.process_events( PygameEventUtils.keydown([pygame.K_PLUS, pygame.K_3, pygame.K_0])) self.assertEqual(app.op, '+') self.assertEqual(app.curr, '30') self.assertEqual(app.prev, '160470') app.process_events(PygameEventUtils.keydown(pygame.K_EQUALS)) self.assertEqual(app.op, '') self.assertEqual(app.curr, '160500') self.assertEqual(app.prev, '') app.process_events( PygameEventUtils.keydown( [pygame.K_SLASH, pygame.K_5, pygame.K_MINUS])) self.assertEqual(app.op, '-') self.assertEqual(app.curr, '') self.assertEqual(app.prev, '32100') app.process_events( PygameEventUtils.keydown([ pygame.K_3, pygame.K_2, pygame.K_1, pygame.K_0, pygame.K_EQUALS ])) self.assertEqual(app.op, '') self.assertEqual(app.curr, '28890') self.assertEqual(app.prev, '') app.process_events( PygameEventUtils.keydown([pygame.K_9, pygame.K_BACKSPACE])) self.assertEqual(app.op, '') self.assertEqual(app.curr, '') self.assertEqual(app.prev, '') # Test methods self.assertRaises(ValueError, lambda: app._format('n')) self.assertEqual(app._format('1.2'), '1') self.assertEqual(app._format('2.0'), '2') # Test selection app.menu._test_print_widgets() b1 = app.menu.get_widgets()[4] b1d = b1.get_decorator() lay = b1.get_attribute('on_layer') self.assertFalse(b1d.is_enabled(lay)) b1.select() self.assertTrue(b1d.is_enabled(lay)) b1.select(False) self.assertFalse(b1d.is_enabled(lay))
def test_update_callback(self) -> None: """ Test update callback. """ def update(event, widget, _) -> None: """ Callback. """ assert isinstance(event, list) widget.set_attribute('attr', True) menu = MenuUtils.generic_menu(theme=TEST_THEME.copy()) btn = menu.add.button('button', lambda: print('Clicked')) call_id = btn.add_update_callback(update) self.assertFalse(btn.get_attribute('attr', False)) click_pos = btn.get_rect(to_real_position=True).center deco = menu.get_decorator() test_draw_rects = True def draw_rect() -> None: """ Draw absolute rect on surface for testing purposes. """ if not test_draw_rects: return surface.fill((0, 255, 0), btn.get_rect(to_real_position=True)) deco.add_callable(draw_rect, prev=False, pass_args=False) click_pos_absolute = btn.get_rect(to_absolute_position=True).center self.assertNotEqual(click_pos, click_pos_absolute) self.assertEqual(menu.get_scrollarea()._view_rect, menu.get_scrollarea().get_absolute_view_rect()) self.assertEqual(btn.get_scrollarea(), menu.get_current().get_scrollarea()) if PYGAME_V2: self.assertEqual(btn.get_rect(), pygame.Rect(253, 153, 94, 41)) self.assertEqual(btn.get_rect(to_real_position=True), pygame.Rect(253, 308, 94, 41)) else: self.assertEqual(btn.get_rect(), pygame.Rect(253, 152, 94, 42)) self.assertEqual(btn.get_rect(to_real_position=True), pygame.Rect(253, 307, 94, 42)) self.assertEqual(len(menu._update_frames), 0) self.assertEqual(len(menu.get_current()._update_frames), 0) btn.update(PygameEventUtils.mouse_click(click_pos[0], click_pos[1])) # MOUSEBUTTONUP self.assertTrue(btn.get_attribute('attr', False)) btn.set_attribute('attr', False) btn.remove_update_callback(call_id) self.assertRaises(IndexError, lambda: btn.remove_update_callback(call_id)) self.assertFalse(btn.get_attribute('attr', False)) btn.update(PygameEventUtils.mouse_click(click_pos[0], click_pos[1])) self.assertFalse(btn.get_attribute('attr', False)) def update2(event, widget, _) -> None: """ Callback. """ assert isinstance(event, list) widget.set_attribute('epic', 'bass') btn.add_update_callback(update2) self.assertFalse(btn.has_attribute('epic')) btn.draw(surface) self.assertFalse(btn.has_attribute('epic')) btn.update(PygameEventUtils.mouse_click(click_pos[0], click_pos[1])) self.assertTrue(btn.has_attribute('epic')) btn.remove_attribute('epic') self.assertRaises(IndexError, lambda: btn.remove_attribute('epic')) self.assertFalse(btn.has_attribute('epic'))
def test_textinput(self) -> None: """ Test TextInput widget. """ menu = MenuUtils.generic_menu() # Assert bad settings self.assertRaises( ValueError, lambda: menu.add.text_input('title', input_type=pygame_menu. locals.INPUT_FLOAT, default='bad')) self.assertRaises( ValueError, # Default and password cannot coexist lambda: menu.add.text_input('title', password=True, default='bad')) # Create text input widget textinput = menu.add.text_input('title', input_underline='_') textinput.set_value('new_value') # No error textinput._selected = False textinput.draw(surface) textinput.select(update_menu=True) textinput.draw(surface) self.assertEqual(textinput.get_value(), 'new_value') textinput.clear() self.assertEqual(textinput.get_value(), '') # Create selection box string = 'the text' textinput._cursor_render = True textinput.set_value(string) textinput._select_all() self.assertEqual(textinput._get_selected_text(), 'the text') textinput.draw(surface) textinput._unselect_text() textinput.draw(surface) # Assert events textinput.update(PygameEventUtils.key(0, keydown=True, testmode=False)) PygameEventUtils.test_widget_key_press(textinput) textinput.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) textinput.update(PygameEventUtils.key(pygame.K_LSHIFT, keydown=True)) textinput.clear() # Type textinput.update( PygameEventUtils.key(pygame.K_t, keydown=True, char='t')) textinput.update( PygameEventUtils.key(pygame.K_e, keydown=True, char='e')) textinput.update( PygameEventUtils.key(pygame.K_s, keydown=True, char='s')) textinput.update( PygameEventUtils.key(pygame.K_t, keydown=True, char='t')) # Keyup textinput.update(PygameEventUtils.key(pygame.K_a, keyup=True, char='a')) self.assertEqual(textinput.get_value(), 'test') # The text we typed # Ctrl events textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_c)) # copy textinput.update(PygameEventUtils.keydown_mod_ctrl( pygame.K_v)) # paste textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_z)) # undo self.assertEqual(textinput.get_value(), 'tes') textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_y)) # redo self.assertEqual(textinput.get_value(), 'test') textinput._select_all() textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_x)) # cut self.assertEqual(textinput.get_value(), '') textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_z)) # undo self.assertEqual(textinput.get_value(), 'test') textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_y)) # redo self.assertEqual(textinput.get_value(), '') textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_z)) # undo self.assertEqual(textinput.get_value(), 'test') # Test ignore ctrl events textinput._copy_paste_enabled = False self.assertFalse( textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_c))) self.assertFalse( textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_v))) max_history = textinput._max_history textinput._max_history = 0 self.assertFalse( textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_z))) self.assertFalse( textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_y))) self.assertFalse( textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_x))) textinput._selection_enabled = False self.assertFalse( textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_a))) self.assertFalse( textinput.update(PygameEventUtils.keydown_mod_ctrl( pygame.K_r))) # invalid # Reset textinput._copy_paste_enabled = True textinput._max_history = max_history textinput._selection_enabled = True # Test selection, if user selects all and types anything the selected # text must be destroyed textinput.update(PygameEventUtils.keydown_mod_ctrl( pygame.K_a)) # select all textinput._unselect_text() self.assertEqual(textinput._get_selected_text(), '') textinput._select_all() self.assertEqual(textinput._get_selected_text(), 'test') textinput._unselect_text() self.assertEqual(textinput._get_selected_text(), '') textinput.update(PygameEventUtils.keydown_mod_ctrl(pygame.K_a)) self.assertEqual(textinput._get_selected_text(), 'test') textinput.update( PygameEventUtils.key(pygame.K_t, keydown=True, char='t')) textinput._select_all() self.assertTrue( textinput.update( PygameEventUtils.key(pygame.K_ESCAPE, keydown=True))) textinput._select_all() self.assertTrue( textinput.update( PygameEventUtils.key(pygame.K_BACKSPACE, keydown=True))) self.assertEqual(textinput.get_value(), '') textinput.set_value('t') # Releasing shift disable selection textinput._selection_active = True textinput.update(PygameEventUtils.key(pygame.K_LSHIFT, keyup=True)) self.assertFalse(textinput._selection_active) # Arrows while selection textinput._select_all() self.assertIsNotNone(textinput._selection_surface) textinput.update(PygameEventUtils.key(pygame.K_LEFT, keydown=True)) self.assertIsNone(textinput._selection_surface) textinput._select_all() self.assertIsNotNone(textinput._selection_surface) textinput.update(PygameEventUtils.key(pygame.K_RIGHT, keydown=True)) self.assertIsNone(textinput._selection_surface) textinput._select_all() textinput._selection_active = True self.assertEqual(textinput._selection_box, [0, 1]) textinput.update(PygameEventUtils.key(pygame.K_LEFT, keydown=True)) self.assertEqual(textinput._selection_box, [0, 0]) textinput._select_all() textinput._selection_active = True textinput.update(PygameEventUtils.key(pygame.K_RIGHT, keydown=True)) self.assertEqual(textinput._selection_box, [0, 1]) # Remove while selection textinput._select_all() textinput.update(PygameEventUtils.key(pygame.K_DELETE, keydown=True)) self.assertEqual(textinput.get_value(), '') textinput.set_value('t') # Now the value must be t self.assertEqual(textinput._get_selected_text(), '') self.assertEqual(textinput.get_value(), 't') # Test readonly textinput.update( PygameEventUtils.key(pygame.K_t, keydown=True, char='k')) self.assertEqual(textinput.get_value(), 'tk') textinput.readonly = True textinput.update( PygameEventUtils.key(pygame.K_t, keydown=True, char='k')) self.assertEqual(textinput.get_value(), 'tk') textinput.readonly = False # Test keyup self.assertIn(pygame.K_t, textinput._keyrepeat_counters.keys()) self.assertFalse( textinput.update( PygameEventUtils.key(pygame.K_t, keyup=True, char='1'))) self.assertNotIn(pygame.K_t, textinput._keyrepeat_counters.keys()) # Test tab self.assertEqual(textinput._tab_size, 4) textinput.update(PygameEventUtils.key(pygame.K_TAB, keydown=True)) self.assertEqual(textinput.get_value(), 'tk ') # Test invalid unicode self.assertFalse( textinput.update(PygameEventUtils.key(pygame.K_1, keydown=True))) # Up/Down disable active status textinput.active = True textinput.update(PygameEventUtils.key(ctrl.KEY_MOVE_UP, keydown=True)) self.assertFalse(textinput.active) textinput.active = True textinput.update(PygameEventUtils.key(ctrl.KEY_MOVE_DOWN, keydown=True)) self.assertFalse(textinput.active) textinput.active = True self.assertTrue( textinput.update( PygameEventUtils.key(pygame.K_ESCAPE, keydown=True))) self.assertFalse(textinput.active) # Test mouse textinput._selected = True textinput._selection_time = 0 textinput.update(PygameEventUtils.middle_rect_click(textinput)) self.assertTrue(textinput._cursor_visible) textinput._select_all() textinput._selection_active = True self.assertEqual(textinput._cursor_position, 6) self.assertEqual(textinput._selection_box, [0, 6]) textinput.update( PygameEventUtils.middle_rect_click(textinput, evtype=pygame.MOUSEBUTTONDOWN)) self.assertEqual(textinput._selection_box, [0, 0]) # Check click pos textinput._check_mouse_collide_input( PygameEventUtils.middle_rect_click(textinput)[0].pos) self.assertEqual(textinput._cursor_position, 6) # Test touch textinput._cursor_position = 0 textinput._check_touch_collide_input( PygameEventUtils.middle_rect_click(textinput)[0].pos) self.assertEqual(textinput._cursor_position, 6) # Update mouse for i in range(50): textinput.update( PygameEventUtils.key(pygame.K_t, keydown=True, char='t')) textinput._update_cursor_mouse(50) textinput._cursor_render = True textinput._render_cursor() # Test multiple are selected menu.add.text_input('title', password=True, input_underline='_').select() self.assertRaises( pygame_menu.menu._MenuMultipleSelectedWidgetsException, lambda: menu.draw(surface)) textinput.clear() textinput.select(update_menu=True) menu.draw(surface) # Clear the menu self.assertEqual(menu._stats.removed_widgets, 0) self.assertEqual(textinput.get_menu(), menu) menu.clear() self.assertIsNone(textinput.get_menu()) self.assertEqual(menu._stats.removed_widgets, 3) menu.add.generic_widget(textinput) self.assertEqual(textinput.get_menu(), menu) menu.clear() self.assertEqual(menu._stats.removed_widgets, 4)
def test_config(self) -> None: """ Configure controls. """ self.assertEqual(ctrl.KEY_APPLY, pygame.K_RETURN) # Change apply to new key ctrl.KEY_APPLY = pygame.K_END self.assertEqual(ctrl.KEY_APPLY, pygame.K_END) # Create new button menu = MenuUtils.generic_menu() test = [False] def click_button() -> None: """ Button apply handler. """ test[0] = not test[0] print('new test value', test) button = menu.add.button('button', click_button) self.assertFalse(test[0]) button.apply() self.assertTrue(test[0]) button.apply() self.assertFalse(test[0]) # Now test new apply button button.update(PygameEventUtils.key(pygame.K_END, keydown=True)) self.assertTrue(test[0]) button.update(PygameEventUtils.key(pygame.K_END, keydown=True)) self.assertFalse(test[0]) # Rollback change ctrl.KEY_APPLY = pygame.K_RETURN # Create new controller object new_ctrl = ctrl.Controller() test_apply = [0] def new_apply(event, _) -> bool: """ Updates apply. """ test_apply[0] += 1 return event.key == pygame.K_a new_ctrl.apply = new_apply button.set_controller(new_ctrl) # Now test new apply button button.update(PygameEventUtils.key(pygame.K_a, keydown=True)) self.assertTrue(test[0]) button.update(PygameEventUtils.key(pygame.K_a, keydown=True)) self.assertFalse(test[0]) self.assertEqual(test_apply[0], 2) button.update(PygameEventUtils.key(pygame.K_END, keydown=True)) self.assertFalse(test[0]) button.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) self.assertFalse( test[0]) # It should do nothing as object has new controller # The same can be done with menu menu.set_controller(new_ctrl)
def test_colorinput(self) -> None: """ Test ColorInput widget. """ def _assert_invalid_color(widg) -> None: """ Assert that the widget color is invalid. :param widg: Widget object """ r, g, b = widg.get_value() self.assertEqual(r, -1) self.assertEqual(g, -1) self.assertEqual(b, -1) def _assert_color(widg, cr, cg, cb) -> None: """ Assert that the widget color is invalid. :param widg: Widget object :param cr: Red channel, number between 0 and 255 :param cg: Green channel, number between 0 and 255 :param cb: Blue channel, number between 0 and 255 """ r, g, b = widg.get_value() self.assertEqual(r, cr) self.assertEqual(g, cg) self.assertEqual(b, cb) menu = MenuUtils.generic_menu(theme=TEST_THEME.copy()) # Base rgb widget = menu.add.color_input('title', color_type='rgb', input_separator=',') widget.set_value((123, 234, 55)) self.assertRaises(AssertionError, lambda: widget.set_value('0,0,0')) self.assertRaises(AssertionError, lambda: widget.set_value(( 255, 0, ))) self.assertRaises(AssertionError, lambda: widget.set_value( (255, 255, -255))) _assert_color(widget, 123, 234, 55) # Test separator widget = menu.add.color_input('color', color_type='rgb', input_separator='+') widget.set_value((34, 12, 12)) self.assertEqual(widget._input_string, '34+12+12') self.assertRaises( AssertionError, lambda: menu.add.color_input( 'title', color_type='rgb', input_separator='')) self.assertRaises( AssertionError, lambda: menu.add.color_input( 'title', color_type='rgb', input_separator=' ')) self.assertRaises( AssertionError, lambda: menu.add.color_input('title', color_type='unknown')) for i in range(10): self.assertRaises( AssertionError, lambda: menu.add.color_input( 'title', color_type='rgb', input_separator=str(i))) # Empty rgb widget = menu.add.color_input('color', color_type='rgb', input_separator=',') PygameEventUtils.test_widget_key_press(widget) self.assertEqual(widget._cursor_position, 0) widget.update(PygameEventUtils.key(pygame.K_RIGHT, keydown=True)) self.assertEqual(widget._cursor_position, 0) _assert_invalid_color(widget) # Write sequence: 2 -> 25 -> 25, -> 25,0, # The comma after the zero must be automatically set self.assertFalse( widget.update(PygameEventUtils.key(0, keydown=True, testmode=False))) widget.update(PygameEventUtils.key(pygame.K_2, keydown=True, char='2')) widget.update(PygameEventUtils.key(pygame.K_5, keydown=True, char='5')) widget.update( PygameEventUtils.key(pygame.K_COMMA, keydown=True, char=',')) self.assertEqual(widget._input_string, '25,') widget.update(PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) self.assertEqual(widget._input_string, '25,0,') _assert_invalid_color(widget) # Now, sequence: 25,0,c -> 25c,0, with cursor c widget.update(PygameEventUtils.key(pygame.K_LEFT, keydown=True)) widget.update(PygameEventUtils.key(pygame.K_LEFT, keydown=True)) widget.update(PygameEventUtils.key(pygame.K_LEFT, keydown=True)) self.assertEqual(widget._cursor_position, 2) # Sequence. 25,0, -> 255,0, -> 255,0, trying to write another 5 in the same position # That should be cancelled because 2555 > 255 widget.update(PygameEventUtils.key(pygame.K_5, keydown=True, char='5')) self.assertEqual(widget._input_string, '255,0,') widget.update(PygameEventUtils.key(pygame.K_5, keydown=True, char='5')) self.assertEqual(widget._input_string, '255,0,') # Invalid left zeros, try to write 255,0, -> 255,00, but that should be disabled widget.update(PygameEventUtils.key(pygame.K_RIGHT, keydown=True)) widget.update(PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) self.assertEqual(widget._input_string, '255,0,') # Second comma cannot be deleted because there's a number between ,0, widget.update(PygameEventUtils.key(pygame.K_BACKSPACE, keydown=True)) self.assertEqual(widget._input_string, '255,0,') widget.update(PygameEventUtils.key(pygame.K_LEFT, keydown=True)) widget.update(PygameEventUtils.key(pygame.K_DELETE, keydown=True)) self.assertEqual(widget._input_string, '255,0,') # Current cursor is at 255c,0, # Now right comma and 0 can be deleted widget.update(PygameEventUtils.key(pygame.K_END, keydown=True)) widget.update(PygameEventUtils.key(pygame.K_BACKSPACE, keydown=True)) widget.update(PygameEventUtils.key(pygame.K_BACKSPACE, keydown=True)) self.assertEqual(widget._input_string, '255,') # Fill with zeros, then number with 2 consecutive 0 types must be 255,0,0 # Commas should be inserted automatically widget.readonly = True widget.update(PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) self.assertEqual(widget._input_string, '255,') widget.readonly = False widget.update(PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) widget.update(PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) self.assertEqual(widget._input_string, '255,0,0') _assert_color(widget, 255, 0, 0) # At this state, user cannot add more zeros at right for i in range(5): widget.update( PygameEventUtils.key(pygame.K_0, keydown=True, char='0')) self.assertEqual(widget._input_string, '255,0,0') widget.get_rect() widget.clear() self.assertEqual(widget._input_string, '') # Assert invalid defaults rgb self.assertRaises( AssertionError, lambda: menu.add.color_input( 'title', color_type='rgb', default=( 255, 255, ))) self.assertRaises( AssertionError, lambda: menu.add.color_input( 'title', color_type='rgb', default=(255, 255))) self.assertRaises( AssertionError, lambda: menu.add.color_input( 'title', color_type='rgb', default=(255, 255, 255, 255))) # Assert hex widget widget = menu.add.color_input('title', color_type='hex') self.assertEqual(widget._input_string, '#') self.assertEqual(widget._cursor_position, 1) _assert_invalid_color(widget) self.assertRaises(AssertionError, lambda: widget.set_value('#FF')) self.assertRaises(AssertionError, lambda: widget.set_value('#FFFFF<')) self.assertRaises(AssertionError, lambda: widget.set_value('#FFFFF')) self.assertRaises(AssertionError, lambda: widget.set_value('#F')) # noinspection SpellCheckingInspection self.assertRaises(AssertionError, lambda: widget.set_value('FFFFF')) self.assertRaises(AssertionError, lambda: widget.set_value('F')) widget.set_value('FF00FF') _assert_color(widget, 255, 0, 255) widget.set_value('#12FfAa') _assert_color(widget, 18, 255, 170) widget.set_value(' 59C1e5') _assert_color(widget, 89, 193, 229) widget.render() widget.draw(surface) widget.clear() self.assertEqual(widget._input_string, '#') # This cannot be empty self.assertEqual(widget._cursor_position, 1) # In hex widget # cannot be deleted widget.update(PygameEventUtils.key(pygame.K_BACKSPACE, keydown=True)) self.assertEqual(widget._cursor_position, 1) widget.update(PygameEventUtils.key(pygame.K_LEFT, keydown=True)) widget.update(PygameEventUtils.key(pygame.K_DELETE, keydown=True)) self.assertEqual(widget._input_string, '#') widget.update(PygameEventUtils.key(pygame.K_END, keydown=True)) for i in range(10): widget.update( PygameEventUtils.key(pygame.K_f, keydown=True, char='f')) self.assertEqual(widget._input_string, '#ffffff') _assert_color(widget, 255, 255, 255) # Test hex formats widget = menu.add.color_input('title', color_type='hex', hex_format='none') widget.set_value('#ff00ff') self.assertFalse( widget.update(PygameEventUtils.key(0, keydown=True, testmode=False))) self.assertEqual(widget.get_value(as_string=True), '#ff00ff') widget.set_value('#FF00ff') self.assertEqual(widget.get_value(as_string=True), '#FF00ff') widget = menu.add.color_input('title', color_type='hex', hex_format='lower') widget.set_value('#FF00ff') self.assertEqual(widget.get_value(as_string=True), '#ff00ff') widget.set_value('AABBcc') self.assertEqual(widget.get_value(as_string=True), '#aabbcc') widget = menu.add.color_input('title', color_type='hex', hex_format='upper') widget.set_value('#FF00ff') self.assertEqual(widget.get_value(as_string=True), '#FF00FF') widget.set_value('AABBcc') self.assertEqual(widget.get_value(as_string=True), '#AABBCC') # Test dynamic sizing widget = menu.add.color_input('title', color_type='hex', hex_format='upper', dynamic_width=True) self.assertEqual(widget.get_width(), 200) widget.set_value('#ffffff') width = 342 if PYGAME_V2 else 345 self.assertEqual(widget.get_width(), width) widget.set_value(None) self.assertEqual(widget.get_width(), 200) self.assertEqual(widget.get_value(as_string=True), '#') widget.set_value('#ffffff') self.assertEqual(widget.get_width(), width) widget.update(PygameEventUtils.key( pygame.K_BACKSPACE, keydown=True)) # remove the last character, now color is invalid self.assertEqual(widget.get_value(as_string=True), '#FFFFF') # is upper widget.render() self.assertEqual(widget.get_width(), 200) widget = menu.add.color_input('title', color_type='hex', hex_format='upper', dynamic_width=False) self.assertEqual(widget.get_width(), width) widget.set_value('#ffffff') self.assertEqual(widget.get_width(), width)
def test_double(self) -> None: """ Test double range slider. """ menu = MenuUtils.generic_menu() # Double slider slider = pygame_menu.widgets.RangeSlider( 'Range', range_text_value_tick_number=3, default_value=(0.2, 1.0), slider_text_value_font=pygame_menu.font.FONT_BEBAS, range_text_value_font=pygame_menu.font.FONT_8BIT, slider_text_value_triangle=False) slider._slider_text_value_vmargin = -2 menu.add.generic_widget(slider, True) slider.draw(surface) slider.draw_after_if_selected(surface) self.assertEqual(slider.get_value(), (0.2, 1.0)) self.assertRaises(AssertionError, lambda: slider.set_value(0.2)) self.assertRaises(AssertionError, lambda: slider.set_value((0.2, 0.2))) self.assertRaises(AssertionError, lambda: slider.set_value((1.0, 0.2))) self.assertRaises(AssertionError, lambda: slider.set_value( (0.2, 0.5, 1.0))) # Test slider selection self.assertTrue(slider._slider_selected[0]) self.assertTrue( slider.update(PygameEventUtils.key(ctrl.KEY_TAB, keydown=True))) self.assertFalse(slider._slider_selected[0]) slider.draw(surface) slider.draw_after_if_selected(surface) # Test click sliders slider_rect = slider._get_slider_inflate_rect(0, to_real_position=True) self.assertTrue( slider.update( PygameEventUtils.middle_rect_click( slider_rect, evtype=pygame.MOUSEBUTTONDOWN))) self.assertTrue(slider._slider_selected[0]) self.assertFalse( slider.update( # Slider already selected PygameEventUtils.middle_rect_click( slider_rect, evtype=pygame.MOUSEBUTTONDOWN))) # Click if sliders are colliding slider.set_value((0.5, 0.50000001)) slider_rect = slider._get_slider_inflate_rect(1, to_real_position=True) self.assertFalse( slider.update( PygameEventUtils.middle_rect_click( slider_rect, evtype=pygame.MOUSEBUTTONDOWN))) self.assertTrue(slider._slider_selected[0]) slider.set_value((0.5, 0.7)) slider_rect = slider._get_slider_inflate_rect(1, to_real_position=True) self.assertTrue( slider.update( PygameEventUtils.middle_rect_click( slider_rect, evtype=pygame.MOUSEBUTTONDOWN))) self.assertTrue(slider._slider_selected[1]) # Test left slider pos = slider._test_get_pos_value(0.5) pos2 = slider._test_get_pos_value(0.6) slider_rect = slider._get_slider_inflate_rect(0, to_real_position=True) self.assertEqual(slider_rect, pygame.Rect(344, 311, 15, 28)) slider.update( PygameEventUtils.middle_rect_click(slider_rect, evtype=pygame.MOUSEBUTTONDOWN)) self.assertTrue(slider._slider_selected[0]) self.assertTrue(slider._scrolling) self.assertTrue(slider._selected_mouse) dx = pos[0] - pos2[0] slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-dx, pos[1]), update_mouse=True)) self.assertEqual(slider.get_value(), (0.6, 0.7)) # As slider moved, ignore this slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-dx, pos[1]), update_mouse=True)) self.assertEqual(slider.get_value(), (0.6, 0.7)) self.assertTrue(slider._scrolling) self.assertTrue(slider._slider_selected[0]) # Move to 0 self.assertTrue(slider._selected_mouse) pos = slider._test_get_pos_value(0) pos2 = slider._test_get_pos_value(0.6) dx = pos[0] - pos2[0] slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(dx, pos[1]), update_mouse=True)) self.assertEqual(slider.get_value(), (0, 0.7)) # Move more than 0.7 pos = slider._test_get_pos_value(0) pos2 = slider._test_get_pos_value(0.75) slider_rect = slider._get_slider_inflate_rect(0, to_real_position=True) dx = pos[0] - pos2[0] slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-dx, pos[1]), update_mouse=True)) self.assertEqual(slider.get_value(), (0, 0.7)) # Move to 0.7 - eps pos = slider._test_get_pos_value(0) pos2 = slider._test_get_pos_value(0.7 - 1e-6) slider_rect = slider._get_slider_inflate_rect(0, to_real_position=True) dx = pos[0] - pos2[0] slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-dx, pos[1]), update_mouse=True)) self.assertAlmostEqual(slider.get_value()[0], 0.7 - 1e-7, places=1) # Ignore if move 0.7 + eps self.assertFalse( slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(1, pos[1]), update_mouse=True))) # Change to right slider_rect = slider._get_slider_inflate_rect(1, to_real_position=True) self.assertTrue( slider.update(PygameEventUtils.key(ctrl.KEY_TAB, keydown=True))) pos = slider._test_get_pos_value(0.7) pos2 = slider._test_get_pos_value(0.8) dx = pos[0] - pos2[0] self.assertFalse( slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-1, pos[1]), update_mouse=True))) self.assertTrue( slider.update( PygameEventUtils.mouse_motion(slider_rect, rel=(-dx, pos[1]), update_mouse=True))) self.assertAlmostEqual(slider.get_value()[1], 0.8) # Test left/right slider.set_value((0.7, 0.8)) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) slider.set_value((0.7, 0.8)) # Ignored slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) slider.set_value((0.7, 0.9)) slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) slider.set_value((0.7, 1.0)) slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) slider.set_value((0.7, 1.0)) slider.set_value((0.7, 0.8)) slider.update(PygameEventUtils.key(ctrl.KEY_TAB, keydown=True)) slider.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) slider.set_value((0.7, 0.8)) slider.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) slider.set_value((0.6, 0.8)) # Reset value slider.reset_value() self.assertEqual(slider.get_value(), (0.2, 1.0))
def test_selector(self) -> None: """ Test selector widget. """ menu = MenuUtils.generic_menu() selector = menu.add.selector('selector', [('1 - Easy', 'EASY'), ('2 - Medium', 'MEDIUM'), ('3 - Hard', 'HARD')], default=1) menu.enable() menu.draw(surface) selector.draw(surface) selector._selected = False selector.draw(surface) # Test events selector.update(PygameEventUtils.key(0, keydown=True, testmode=False)) selector.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) selector.update(PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)) selector.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True)) selector.update(PygameEventUtils.joy_hat_motion(ctrl.JOY_LEFT)) selector.update(PygameEventUtils.joy_hat_motion(ctrl.JOY_RIGHT)) selector.update(PygameEventUtils.joy_motion(1, 0)) selector.update(PygameEventUtils.joy_motion(-1, 0)) click_pos = selector.get_rect(to_real_position=True, apply_padding=False).center selector.update( PygameEventUtils.mouse_click(click_pos[0], click_pos[1])) # Check left/right clicks self.assertEqual(selector.get_index(), 0) click_pos = selector.get_rect(to_real_position=True, apply_padding=False).midleft selector.update( PygameEventUtils.mouse_click(click_pos[0] + 150, click_pos[1])) self.assertEqual(selector.get_index(), 2) selector.update( PygameEventUtils.mouse_click(click_pos[0] + 150, click_pos[1])) self.assertEqual(selector.get_index(), 1) selector.update( PygameEventUtils.mouse_click(click_pos[0] + 150, click_pos[1])) self.assertEqual(selector.get_index(), 0) selector.update( PygameEventUtils.mouse_click(click_pos[0] + 250, click_pos[1])) self.assertEqual(selector.get_index(), 1) selector.update( PygameEventUtils.mouse_click(click_pos[0] + 250, click_pos[1])) self.assertEqual(selector.get_index(), 2) selector.update( PygameEventUtils.mouse_click(click_pos[0] + 250, click_pos[1])) self.assertEqual(selector.get_index(), 0) # Test left/right touch click_pos = selector.get_rect(to_real_position=True, apply_padding=False).midleft selector._touchscreen_enabled = True selector.update( PygameEventUtils.touch_click(click_pos[0] + 150, click_pos[1], menu=selector.get_menu())) self.assertEqual(selector.get_index(), 2) selector.update( PygameEventUtils.touch_click(click_pos[0] + 250, click_pos[1], menu=selector.get_menu())) self.assertEqual(selector.get_index(), 0) selector.update( PygameEventUtils.touch_click(click_pos[0] + 250, click_pos[1], menu=selector.get_menu())) self.assertEqual(selector.get_index(), 1) # Update elements new_elements = [('4 - Easy', 'EASY'), ('5 - Medium', 'MEDIUM'), ('6 - Hard', 'HARD')] selector.update_items(new_elements) selector.set_value('6 - Hard') self.assertEqual(selector.get_value()[1], 2) self.assertRaises(AssertionError, lambda: selector.set_value(bool)) self.assertRaises(AssertionError, lambda: selector.set_value(200)) selector.set_value(1) self.assertEqual(selector.get_value()[1], 1) self.assertEqual(selector.get_value()[0][0], '5 - Medium') selector.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(selector.get_value()[0][0], '4 - Easy') selector.readonly = True selector.update(PygameEventUtils.key(ctrl.KEY_LEFT, keydown=True)) self.assertEqual(selector.get_value()[0][0], '4 - Easy') selector._left() self.assertEqual(selector.get_value()[0][0], '4 - Easy') selector._right() self.assertEqual(selector.get_value()[0][0], '4 - Easy') # Test fancy selector sel_fancy = menu.add.selector( 'Fancy ', [('1 - Easy', 'EASY'), ('2 - Medium', 'MEDIUM'), ('3 - Hard', 'HARD')], default=1, style=pygame_menu.widgets.widget.selector.SELECTOR_STYLE_FANCY) self.assertEqual(sel_fancy.get_items(), [('1 - Easy', 'EASY'), ('2 - Medium', 'MEDIUM'), ('3 - Hard', 'HARD')]) self.assertRaises( AssertionError, lambda: menu.add.selector('title', [('a', 'a'), ('b', 'b')], default=2))
def test_menu_link(self) -> None: """ Test menu link. """ menu = MenuUtils.generic_menu() menu1 = MenuUtils.generic_menu(title='Menu1', theme=pygame_menu.themes.THEME_BLUE) menu1.add.button('Back', pygame_menu.events.BACK) menu2 = MenuUtils.generic_menu(title='Menu2', theme=pygame_menu.themes.THEME_ORANGE) menu2.add.button('Back', pygame_menu.events.BACK) menu3 = MenuUtils.generic_menu(title='Menu3', theme=pygame_menu.themes.THEME_GREEN) menu3.add.button('Back', pygame_menu.events.BACK) btn1 = menu.add.button('menu1', menu1) btn2 = menu.add.button('menu2', menu2) btn3 = menu.add.button('menu3', menu3) # Hide the buttons btn1.hide() btn2.hide() btn3.hide() # Now open menu with the button, this should open Menu1 by default self.assertEqual(menu.get_current(), menu) btn1.apply() self.assertEqual(menu.get_current(), menu1) menu.full_reset() self.assertEqual(menu.get_current(), menu) # Add menu link link_test = menu.add.menu_link(menu2) link_test.open() self.assertEqual(menu.get_current(), menu2) menu.full_reset() self.assertEqual(menu.get_current(), menu) self.assertFalse(link_test.is_visible()) link_test.hide() self.assertFalse(link_test.is_visible()) link_test.show() self.assertFalse(link_test.is_visible()) self.assertRaises(ValueError, lambda: menu.add.menu_link(menu)) # Invalid objects self.assertRaises(ValueError, lambda: menu.add.menu_link(True)) # noinspection PyMissingTypeHints,PyMissingOrEmptyDocstring def open_link(*args) -> None: link: 'pygame_menu.widgets.MenuLink' = args[-1] self.assertIsInstance(link, pygame_menu.widgets.MenuLink) link.open() # Add a selection object, which opens the links sel = menu.add.selector('Change menu ', [('Menu 1', menu.add.menu_link(menu1)), ('Menu 2', menu.add.menu_link(menu2)), ('Menu 3', menu.add.menu_link(menu3))], onreturn=open_link, style=pygame_menu.widgets.SELECTOR_STYLE_FANCY) sel.update(PygameEventUtils.key(ctrl.KEY_APPLY, keydown=True))