def test_font_load(self) -> None:
"""
Load a font from a file.
"""
font = MenuUtils.get_font(pygame_menu.font.FONT_8BIT, 5)
self.assertTrue(font is not None)
self.assertEqual(font, pygame_menu.font.get_font(font, 5))
self.assertRaises(ValueError, lambda: MenuUtils.get_font('', 0))
self.assertRaises(ValueError, lambda: MenuUtils.get_font('sys', 0))
def test_system_load(self) -> None:
"""
Test fonts from system.
"""
font_sys = MenuUtils.random_system_font()
font = MenuUtils.get_font(font_sys, 5)
self.assertTrue(font is not None)
# Modify the system font and load, this will raise an exception
self.assertRaises(ValueError, lambda: MenuUtils.get_font('invalid font', 5))
def test_example_difficulty_selector() -> None:
"""
Test multi-input example.
"""
game_selector.main(test=True)
font = MenuUtils.load_font(MenuUtils.random_font(), 5)
game_selector.play_function(['EASY'], font, test=True)
game_selector.play_function(['MEDIUM'], font, test=True)
game_selector.play_function(['HARD'], font, test=True)
test_reset_surface()
def test_copy(self) -> None:
"""
Test theme copy.
"""
image = pygame_menu.BaseImage(
pygame_menu.baseimage.IMAGE_EXAMPLE_GRAY_LINES)
# Create theme
theme = pygame_menu.themes.THEME_DEFAULT.copy()
theme.background_color = image
# Copy the theme
theme_copy = theme.copy()
self.assertNotEqual(theme.background_color,
theme_copy.background_color)
self.assertNotEqual(theme.background_color,
pygame_menu.themes.THEME_DEFAULT.background_color)
# Test attribute copy
color_main = (29, 120, 107, 255)
color_copy = (241, 125, 1)
theme_white = pygame_menu.themes.Theme(scrollbar_thick=50,
selection_color=color_main)
sub_theme_white = theme_white.copy()
sub_theme_white.selection_color = color_copy
self.assertEqual(theme_white.selection_color, color_main)
self.assertEqual(sub_theme_white.selection_color, color_copy)
self.assertNotEqual(theme_white.selection_color,
sub_theme_white.selection_color)
self.assertNotEqual(theme_white.widget_selection_effect,
sub_theme_white.widget_selection_effect)
# Test the widget effect color is different in both objects
m1 = MenuUtils.generic_menu(theme=theme_white)
m2 = MenuUtils.generic_menu(theme=sub_theme_white)
b1 = m1.add.button('1')
b2 = m2.add.button('2')
self.assertEqual(b1._selection_effect.color,
b1.get_menu().get_theme().selection_color)
self.assertEqual(b2._selection_effect.color,
b2.get_menu().get_theme().selection_color)
self.assertNotEqual(b1._selection_effect.color,
b2._selection_effect.color)
# Main Theme selection effect class should not be modified
self.assertEqual(b1.get_menu().get_theme(), theme_white)
self.assertEqual(theme_white.widget_selection_effect.color, (0, 0, 0))
def test_password(self) -> None:
"""
Test password.
"""
if SYS_PLATFORM_OSX:
return
menu = MenuUtils.generic_menu()
password_input = menu.add.text_input('title',
password=True,
input_underline='_')
self.assertRaises(
ValueError, # Password cannot be set
lambda: password_input.set_value('new_value'))
password_input.set_value('') # No error
password_input._selected = False
password_input.draw(surface)
password_input.select(update_menu=True)
password_input.draw(surface)
self.assertEqual(password_input.get_value(), '')
password_input.clear()
self.assertEqual(password_input.get_value(), '')
# Test none width password
password_input._password_char = ''
self.assertRaises(ValueError, lambda: password_input._apply_font())
def test_menu_compatibility(self) -> None:
"""
Menu compatibility.
"""
# Test Menu constructor
# noinspection PyTypeChecker
menu = pygame_menu.Menu(400, 300, 'title')
self.assertEqual(menu._width, 300)
self.assertEqual(menu._height, 400)
self.assertEqual(menu.get_title(), 'title')
# Test widget addition compatibility
menu = MenuUtils.generic_menu()
self.assertIsInstance(menu.add_button('title', None),
pygame_menu.widgets.Button)
self.assertIsInstance(menu.add_color_input('title', 'rgb'),
pygame_menu.widgets.ColorInput)
self.assertIsInstance(
menu.add_image(pygame_menu.baseimage.IMAGE_EXAMPLE_PYGAME_MENU),
pygame_menu.widgets.Image)
self.assertIsInstance(menu.add_label('title'),
pygame_menu.widgets.Label)
self.assertIsInstance(
menu.add_selector(title='epic selector',
items=[('1', '3'), ('2', '4')]),
pygame_menu.widgets.Selector)
self.assertIsInstance(
menu.add_text_input(title='text', default='the default text'),
pygame_menu.widgets.TextInput)
self.assertIsInstance(menu.add_vertical_margin(10),
pygame_menu.widgets.VMargin)
self.assertIsInstance(
menu.add_generic_widget(pygame_menu.widgets.NoneWidget()),
pygame_menu.widgets.NoneWidget)
def test_empty_title(self) -> None:
"""
Test empty title.
"""
menu = MenuUtils.generic_menu()
sel = menu.add.selector('', [('a', 'a'), ('b', 'b')])
self.assertEqual(sel.get_size(), (83, 49))
def test_progressbar(self) -> None:
"""
Test progressbar slider.
"""
menu = MenuUtils.generic_menu()
pb = pygame_menu.widgets.ProgressBar(
'progress', progress_text_font=pygame_menu.font.FONT_BEBAS)
menu.add.generic_widget(pb, configure_defaults=True)
menu.draw(surface)
self.assertRaises(
AssertionError,
lambda: pygame_menu.widgets.ProgressBar('progress', default=-1))
self.assertEqual(pb.get_size(), (312, 49))
self.assertEqual(pb._width, 150)
# Test invalid transforms
self.assertRaises(WidgetTransformationNotImplemented,
lambda: pb.rotate())
self.assertRaises(WidgetTransformationNotImplemented,
lambda: pb.flip())
self.assertRaises(WidgetTransformationNotImplemented,
lambda: pb.scale())
self.assertRaises(WidgetTransformationNotImplemented,
lambda: pb.resize())
self.assertRaises(WidgetTransformationNotImplemented,
lambda: pb.set_max_width())
self.assertRaises(WidgetTransformationNotImplemented,
lambda: pb.set_max_height())
self.assertFalse(pb.update([]))
def test_undo_redo(self) -> None:
"""
Test undo/redo.
"""
menu = MenuUtils.generic_menu()
# Test maxchar and undo/redo
textinput = menu.add.text_input('title',
input_underline='_',
maxchar=20)
textinput.set_value(
'the size of this textinput is way greater than the limit')
self.assertEqual(textinput.get_value(),
'eater than the limit') # same as maxchar
self.assertEqual(textinput._cursor_position, 20)
textinput._undo() # This must set default at ''
self.assertEqual(textinput.get_value(), '')
textinput._redo()
self.assertEqual(textinput.get_value(), 'eater than the limit')
textinput.draw(surface)
textinput._copy()
textinput._paste()
textinput._block_copy_paste = False
textinput._select_all()
textinput._cut()
self.assertEqual(textinput.get_value(), '')
textinput._undo()
self.assertEqual(textinput.get_value(), 'eater than the limit')
self.assertEqual(textinput._history_index, 1)
textinput._history_index = 0
self.assertFalse(textinput._undo())
textinput._history_index = len(textinput._history) - 1
self.assertFalse(textinput._redo())
def test_value(self) -> None:
"""
Test textinput value.
"""
menu = MenuUtils.generic_menu()
test = ['']
def onwidgetchange(m: 'pygame_menu.Menu',
w: 'pygame_menu.widgets.Widget') -> None:
"""
Callback executed if widget changes.
"""
self.assertIn(w, m.get_widgets())
test[0] = w.get_value()
menu.set_onwidgetchange(onwidgetchange)
# Text
text = menu.add.text_input('title', 'value')
self.assertEqual(test[0], '')
self.assertEqual(text.get_value(), 'value')
self.assertFalse(text.value_changed())
text.set_value('new')
self.assertEqual(text.get_value(), 'new')
self.assertTrue(text.value_changed())
text.reset_value()
self.assertEqual(text.get_value(), 'value')
self.assertFalse(text.value_changed())
text.change()
self.assertEqual(test[0], 'value')
# Color
color = menu.add.color_input('title',
color_type='hex',
hex_format='none')
self.assertEqual(color._default_value, '')
self.assertEqual(color.get_value(), (-1, -1, -1))
self.assertFalse(color.value_changed())
self.assertRaises(AssertionError, lambda: color.set_value((255, 0, 0)))
color.set_value('ff0000')
self.assertEqual(color.get_value(), (255, 0, 0))
self.assertTrue(color.value_changed())
color.reset_value()
self.assertEqual(color.get_value(), (-1, -1, -1))
self.assertFalse(color.value_changed())
color = menu.add.color_input('title',
color_type='hex',
hex_format='none',
default='#ff0000')
self.assertEqual(color._default_value, '#ff0000')
self.assertEqual(color.get_value(), (255, 0, 0))
self.assertFalse(color.value_changed())
color.set_value('#00ff00')
self.assertEqual(color.get_value(), (0, 255, 0))
self.assertTrue(color.value_changed())
color.reset_value()
self.assertEqual(color.get_value(), (255, 0, 0))
self.assertFalse(color.value_changed())
def test_padding(self) -> None:
"""
Test widget padding.
"""
menu = MenuUtils.generic_menu()
self.assertRaises(
Exception,
lambda: menu.add.button(0, pygame_menu.events.NONE, padding=-1))
self.assertRaises(
Exception,
lambda: menu.add.button(0, pygame_menu.events.NONE, padding='a'))
self.assertRaises(
Exception, lambda: menu.add.button(
0, pygame_menu.events.NONE, padding=(0, 0, 0, 0, 0)))
self.assertRaises(
Exception, lambda: menu.add.button(
0, pygame_menu.events.NONE, padding=(0, 0, -1, 0)))
self.assertRaises(
Exception, lambda: menu.add.button(
0, pygame_menu.events.NONE, padding=(0, 0, 'a', 0)))
w = menu.add.button(0, pygame_menu.events.NONE, padding=25)
self.assertEqual(w.get_padding(), (25, 25, 25, 25))
w = menu.add.button(0,
pygame_menu.events.NONE,
padding=(25, 50, 75, 100))
self.assertEqual(w.get_padding(), (25, 50, 75, 100))
w = menu.add.button(0, pygame_menu.events.NONE, padding=(25, 50))
self.assertEqual(w.get_padding(), (25, 50, 25, 50))
w = menu.add.button(0, pygame_menu.events.NONE, padding=(25, 75, 50))
self.assertEqual(w.get_padding(), (25, 75, 50, 75))
def test_widget_floating_zero(self) -> None:
"""
Test widgets with zero position if floated.
"""
menu = MenuUtils.generic_menu(title='Example menu')
img = pygame_menu.BaseImage(
pygame_menu.baseimage.IMAGE_EXAMPLE_PYGAME_MENU)
img.scale(0.3, 0.3)
image_widget = menu.add.image(image_path=img.copy())
image_widget.set_border(1, 'black')
image_widget.set_float(origin_position=True)
menu.render()
# Test position
self.assertEqual(image_widget.get_position(), (8, 60))
# Image translate
image_widget.translate(100, 100)
self.assertEqual(image_widget.get_position(), (8, 60))
# Render, then update the position
menu.render()
self.assertEqual(image_widget.get_position(), (108, 160))
image_widget.translate(-50, 0)
menu.render()
self.assertEqual(image_widget.get_position(), (-42, 60))
def test_decorator(self) -> None:
"""
Test decorator.
"""
sa = MenuUtils.generic_menu().get_scrollarea()
dec = sa.get_decorator()
self.assertEqual(sa, dec._obj)
def test_empty_title(self) -> None:
"""
Test empty title.
"""
menu = MenuUtils.generic_menu()
text = menu.add.text_input('')
self.assertEqual(text.get_size(), (16, 49))
def test_scrollbars(self) -> None:
"""
Test scrollarea scrollbar's.
"""
menu = MenuUtils.generic_menu(touchscreen=False,
mouse_enabled=False,
joystick_enabled=False,
keyboard_enabled=False)
sa = menu.get_scrollarea()
sb = sa._scrollbars[0]
self.assertFalse(sb._joystick_enabled)
self.assertFalse(sb._keyboard_enabled)
self.assertFalse(sb._mouse_enabled)
self.assertFalse(sb._touchscreen_enabled)
# Test scrollarea within frame
drop = menu.add.dropselect('Subject Id',
items=[('a', ), ('b', ), ('c', )],
dropselect_id='s0')
d_frame_sa = drop._drop_frame.get_scrollarea(inner=True)
sb_frame = d_frame_sa._scrollbars[0]
self.assertFalse(sb_frame._joystick_enabled)
self.assertFalse(sb_frame._keyboard_enabled)
self.assertFalse(sb_frame._mouse_enabled)
self.assertFalse(sb_frame._touchscreen_enabled)
self.assertEqual(sb_frame.get_menu(), menu)
self.assertEqual(d_frame_sa.get_menu(), menu)
def test_show_hide_scrollbars(self) -> None:
"""
Test show hide scrollbars.
"""
menu = MenuUtils.generic_menu()
sa = menu.get_scrollarea()
menu.render()
menu.draw(surface)
for s in sa._scrollbars:
s.show()
if sa._scrollbars[1].get_orientation() == ORIENTATION_VERTICAL:
s1 = sa._scrollbars[1]
s2 = sa._scrollbars[0]
else:
s1 = sa._scrollbars[0]
s2 = sa._scrollbars[1]
self.assertTrue(s1.is_visible())
sa.hide_scrollbars(ORIENTATION_VERTICAL)
self.assertFalse(s1.is_visible())
self.assertTrue(s2.is_visible())
sa.hide_scrollbars(ORIENTATION_HORIZONTAL)
self.assertFalse(s1.is_visible())
self.assertFalse(s2.is_visible())
sa.show_scrollbars(ORIENTATION_HORIZONTAL)
sa.show_scrollbars(ORIENTATION_VERTICAL)
self.assertTrue(s1.is_visible())
self.assertTrue(s2.is_visible())
def test_copy(self) -> None:
"""
Test copy.
"""
sa = MenuUtils.generic_menu().get_scrollarea()
self.assertRaises(pygame_menu._scrollarea._ScrollAreaCopyException, lambda: copy.copy(sa))
self.assertRaises(pygame_menu._scrollarea._ScrollAreaCopyException, lambda: copy.deepcopy(sa))
def test_empty_title(self) -> None:
"""
Test empty title.
"""
menu = MenuUtils.generic_menu()
switch = menu.add.toggle_switch('')
self.assertEqual(switch.get_size(), (191, 49))
def test_empty_title(self) -> None:
"""
Test empty title.
"""
menu = MenuUtils.generic_menu()
r = menu.add.range_slider('', 0.5, (0, 1), 0.1)
self.assertEqual(r.get_size(), (198, 66))
def test_scale_maxwidth_height(self) -> None:
"""
Test the interaction between scale, max width and max height.
"""
menu = MenuUtils.generic_menu()
btn = menu.add.button('button')
btn.scale(1, 1)
btn.scale(2, 3)
self.assertTrue(btn._scale[0])
self.assertEqual(btn._scale[1], 2)
self.assertEqual(btn._scale[2], 3)
# Now, set max width
btn.set_max_width(150)
self.assertFalse(btn._scale[0])
btn.set_max_height(150)
self.assertFalse(btn._scale[0])
self.assertIsNone(btn._max_width[0])
btn.scale(2, 2)
self.assertIsNone(btn._max_height[0])
self.assertTrue(btn._scale[0])
self.assertEqual(btn._scale[1], 2)
self.assertEqual(btn._scale[2], 2)
def test_value(self) -> None:
"""
Test rangeslider value.
"""
menu = MenuUtils.generic_menu()
# Single
r = menu.add.range_slider('Range', 0.5, (0, 1), 0.1)
self.assertEqual(r.get_value(), 0.5)
self.assertFalse(r.value_changed())
r.set_value(0.8)
self.assertTrue(r.value_changed())
self.assertEqual(r.get_value(), 0.8)
r.reset_value()
self.assertEqual(r.get_value(), 0.5)
self.assertFalse(r.value_changed())
# Double
r = menu.add.range_slider('Range', [0.2, 0.6], (0, 1), 0.1)
self.assertEqual(r.get_value(), (0.2, 0.6))
self.assertFalse(r.value_changed())
self.assertRaises(AssertionError, lambda: r.set_value(0.8))
r.set_value((0.5, 1))
self.assertTrue(r.value_changed())
self.assertEqual(r.get_value(), (0.5, 1))
r.reset_value()
self.assertEqual(r.get_value(), (0.2, 0.6))
self.assertFalse(r.value_changed())
def test_kwargs(self) -> None:
"""
Test kwargs addition.
"""
def function_kwargs(*args, **kwargs) -> None:
"""
Button callback.
"""
self.assertEqual(len(args), 0)
kwargs_k = list(kwargs.keys())
self.assertEqual(kwargs_k[0], 'test')
self.assertEqual(kwargs_k[1], 'widget')
menu = MenuUtils.generic_menu()
self.assertRaises(
ValueError,
lambda: menu.add.button('btn', function_kwargs, test=True))
btn = menu.add.button('btn',
function_kwargs,
test=True,
accept_kwargs=True,
padding=10)
self.assertEqual(len(btn._kwargs), 1)
self.assertRaises(KeyError, lambda: btn.add_self_to_kwargs('test'))
self.assertEqual(len(btn._kwargs), 1)
btn.add_self_to_kwargs()
self.assertEqual(len(btn._kwargs), 2)
self.assertEqual(btn._kwargs['widget'], btn)
btn.apply()
def test_sound_menu(self) -> None:
"""
Test sounds in menu.
"""
menu = MenuUtils.generic_menu()
submenu = MenuUtils.generic_menu()
menu.add.button('submenu', submenu)
button = menu.add.button('button', lambda: None)
menu.set_sound(self.sound, True)
self.assertEqual(button.get_sound(), self.sound)
# This will remove the sound engine
menu.set_sound(None, True)
self.assertNotEqual(button.get_sound(), self.sound)
self.assertEqual(menu.get_sound(), menu._sound)
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_shadow(self) -> None:
"""
Test shadow.
"""
menu = MenuUtils.generic_menu()
w = menu.add.vertical_margin(1)
w.shadow(10, 10)
self.assertFalse(w._shadow['enabled'])
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_empty_title(self) -> None:
"""
Test empty title.
"""
menu = MenuUtils.generic_menu()
label = menu.add.label('')
p = label._padding
self.assertEqual(label.get_width(), p[1] + p[3])
self.assertEqual(label.get_height(), p[0] + p[2] + 41 if PYGAME_V2 else 42)
def test_value(self) -> None:
"""
Test value.
"""
menu = MenuUtils.generic_menu()
menu2 = MenuUtils.generic_menu()
widgets = [
menu.add.none_widget(),
menu.add.vertical_margin(1),
menu.add.horizontal_margin(1),
menu.add.menu_link(menu2)
]
for w in widgets:
self.assertRaises(ValueError, lambda: w.get_value())
self.assertRaises(ValueError, lambda: w.set_value('value'))
self.assertRaises(ValueError, lambda: w.set_default_value('value'))
self.assertFalse(w.value_changed())
w.reset_value()
def test_change_area_color(self) -> None:
"""
Test area color.
"""
menu = MenuUtils.generic_menu()
sa = menu.get_scrollarea()
sf = sa._bg_surface
self.assertEqual(sa.update_area_color('red'), sa)
self.assertNotEqual(sf, sa._bg_surface)
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)
