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_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_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_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)