def test_gl_create_delete_context(self):
self.assertRaises((AttributeError, TypeError),
video.gl_create_context, None)
self.assertRaises((AttributeError, TypeError),
video.gl_create_context, "Test")
self.assertRaises((AttributeError, TypeError),
video.gl_create_context, 1234)
window = video.create_window("No OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_BORDERLESS)
self.assertRaises(sdl.SDLError, video.gl_create_context, window)
video.destroy_window(window)
self.assertTrue(video.gl_load_library())
window = video.create_window("OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.gl_create_context(window)
video.gl_delete_context(ctx)
video.destroy_window(window)
window = video.create_window("OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.gl_create_context(window)
video.destroy_window(window)
video.gl_delete_context(ctx)
video.gl_unload_library()
def test_get_set_render_draw_color(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
for i in range(render.get_num_render_drivers()):
renderer = render.create_renderer(window, i,
render.SDL_RENDERER_ACCELERATED)
self.assertIsInstance(renderer, render.SDL_Renderer)
colors = ((16, 22, 185, 217),
(32, 64, 128, 255),
(64, 32, 128, 255),
(64, 32, 255, 128),
(255, 32, 64, 128),
(255, 32, 128, 64),
(0, 0, 0, 0),
(255, 255, 255, 255),
(128, 128, 128, 255),
)
for r, g, b, a in colors:
render.set_render_draw_color(renderer, r, g, b, a)
dr, dg, db, da = render.get_render_draw_color(renderer)
self.assertEqual((dr, dg, db, da), (r, g, b, a))
render.destroy_renderer(renderer)
self.assertRaises(sdl.SDLError, render.set_render_draw_color,
renderer, 10, 20, 30, 40)
self.assertRaises(sdl.SDLError, render.get_render_draw_color,
renderer)
video.destroy_window(window)
def test_get_set_texture_blend_mode(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
tex = render.create_texture(renderer, pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10, 10)
self.assertIsInstance(tex, render.SDL_Texture)
modes = (video.SDL_BLENDMODE_NONE,
video.SDL_BLENDMODE_ADD,
video.SDL_BLENDMODE_BLEND,
video.SDL_BLENDMODE_MOD,
)
for mode in modes:
render.set_texture_blend_mode(tex, mode)
tmode = render.get_texture_blend_mode(tex)
self.assertEqual(tmode, mode)
render.destroy_texture(tex)
self.assertRaises(sdl.SDLError, render.set_texture_blend_mode, tex,
modes[2])
self.assertRaises(sdl.SDLError, render.get_texture_blend_mode, tex)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_get_set_texture_color_mod(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
tex = render.create_texture(renderer, pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10, 10)
self.assertIsInstance(tex, render.SDL_Texture)
colors = ((16, 22, 185),
(32, 64, 128),
(64, 32, 128),
(64, 32, 255),
(255, 32, 64),
(255, 32, 128),
(0, 0, 0),
(255, 255, 255),
(128, 128, 128),
)
for r, g, b in colors:
render.set_texture_color_mod(tex, r, g, b)
tr, tg, tb = render.get_texture_color_mod(tex)
self.assertEqual((tr, tg, tb), (r, g, b))
render.destroy_texture(tex)
self.assertRaises(sdl.SDLError, render.set_texture_color_mod, tex,
10, 20, 30)
self.assertRaises(sdl.SDLError, render.get_texture_color_mod, tex)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_query_texture(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
formats = (pixels.SDL_PIXELFORMAT_ARGB8888,
pixels.SDL_PIXELFORMAT_RGB555,
pixels.SDL_PIXELFORMAT_RGBA4444,
pixels.SDL_PIXELFORMAT_ARGB2101010,
pixels.SDL_PIXELFORMAT_YUY2
)
access = (render.SDL_TEXTUREACCESS_STATIC,
render.SDL_TEXTUREACCESS_STREAMING,
render.SDL_TEXTUREACCESS_TARGET)
for fmt in formats:
for acc in access:
for w in range(1, 300, 5):
for h in range(1, 300, 5):
tex = render.create_texture(renderer, fmt, acc, w, h)
self.assertIsInstance(tex, render.SDL_Texture)
qf, qa, qw, qh = render.query_texture(tex)
self.assertEqual(qf, fmt)
self.assertEqual(qa, acc)
self.assertEqual(w, qw)
self.assertEqual(h, qh)
render.destroy_texture(tex)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_get_set_render_draw_blend_mode(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
for i in range(render.get_num_render_drivers()):
renderer = render.create_renderer(window, i,
render.SDL_RENDERER_ACCELERATED)
self.assertIsInstance(renderer, render.SDL_Renderer)
modes = (video.SDL_BLENDMODE_NONE,
video.SDL_BLENDMODE_ADD,
video.SDL_BLENDMODE_BLEND,
video.SDL_BLENDMODE_MOD,
)
for mode in modes:
render.set_render_draw_blend_mode(renderer, mode)
bmode = render.get_render_draw_blend_mode(renderer)
self.assertEqual(bmode, mode)
render.destroy_renderer(renderer)
self.assertRaises(sdl.SDLError, render.set_render_draw_blend_mode,
renderer, video.SDL_BLENDMODE_ADD)
self.assertRaises(sdl.SDLError, render.get_render_draw_blend_mode,
renderer)
video.destroy_window(window)
def __init__(self, title, size, position=None, flags=None):
"""Creates a Window with a specific size and title.
The position to show the Window at is undefined by default,
letting the operating system or window manager pick the best
location. The behaviour can be adjusted through the DEFAULTPOS
class variable:
Window.DEFAULTPOS = (10, 10)
The created Window is hidden by default, which can be overriden
at the time of creation by providing other SDL window flags
through the flags parameter.
The default flags for creating Window instances can be adjusted
through the DEFAULTFLAGS class variable:
Window.DEFAULTFLAGS = pygame2.sdl.video.SDL_WINDOW_SHOWN
"""
if position is None:
position = self.DEFAULTPOS
if flags is None:
flags = self.DEFAULTFLAGS
self.window = sdlvideo.create_window(title, position[0], position[1], size[0], size[1], flags)
self._renderer = None # used by get_renderer()
def test_gl_get_set_swap_interval(self):
self.assertRaises(ValueError, video.gl_set_swap_interval, None)
self.assertRaises(ValueError, video.gl_set_swap_interval, "Test")
self.assertRaises(ValueError, video.gl_set_swap_interval, 1234)
# No current OpenGL context yet.
# Might crash on certain platforms, since the internal state of
# SDL2 does not support calling GL functions without having a
# GL library loaded.
# self.assertRaises(sdl.SDLError, video.gl_set_swap_interval, 1)
# self.assertRaises(sdl.SDLError, video.gl_set_swap_interval, 0)
self.assertTrue(video.gl_load_library())
window = video.create_window("OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.gl_create_context(window)
video.gl_make_current(window, ctx)
video.gl_set_swap_interval(0)
self.assertEqual(video.gl_get_swap_interval(), 0)
video.gl_set_swap_interval(1)
self.assertEqual(video.gl_get_swap_interval(), 1)
video.gl_delete_context(ctx)
video.destroy_window(window)
video.gl_unload_library()
def test_destroy_window(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
# TODO: how to check for this in a meaningful way?
video.destroy_window(window)
def test_update_window_surface(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
for flag in flags:
window = video.create_window("Test", 200, 200, 200, 200, flag)
video.update_window_surface(window)
video.destroy_window(window)
def test_get_window_wm_info(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
wminfo = syswm.get_window_wm_info(window)
self.assertEqual(wminfo.version.major, 2)
self.assertEqual(wminfo.version.minor, 0)
self.assertEqual(wminfo.version.patch, 0)
video.destroy_window(window)
def test_get_set_window_title(self):
window = video.create_window("Test", 10, 10, 10, 10, 0)
self.assertEqual(video.get_window_title(window), "Test")
video.set_window_title(window, "Hello there")
self.assertEqual(video.get_window_title(window), "Hello there")
video.set_window_title(window, 123456789)
self.assertEqual(video.get_window_title(window), "123456789")
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_title, window)
def test_get_window_flags(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
wflags = video.get_window_flags(window)
# TODO: this constantly fails - why?
self.assertEqual((wflags & flag), flag)
def test_get_window_id(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
id = video.get_window_id(window)
self.assertIsInstance(id, int)
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_id, window)
def test_create_texture_from_surface(self):
sf = surface.create_rgb_surface(100, 100, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
def test_maximize_window(self):
window = video.create_window("test_maximize_window", 200, 200,
200, 200, video.SDL_WINDOW_RESIZABLE)
video.show_window(window)
doprint("""Please check, that a window with the title
'test_maximize_window' is shown""")
video.maximize_window(window)
doprint("Please check, if the window was maximized properly")
video.destroy_window(window)
def test_minimize_window(self):
window = video.create_window("test_minimize_window", 200, 200,
200, 200, 0)
video.show_window(window)
doprint("""Please check, that a window with the title
'test_minimize_window' is shown""")
video.minimize_window(window)
doprint("Please check, if the window was minimized properly")
video.destroy_window(window)
def test_get_window_display_mode(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
dmode = video.get_window_display_mode(window)
self.assertIsInstance(dmode, video.SDL_DisplayMode)
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_display_mode,
window)
def test_get_set_window_position(self):
window = video.create_window("Test", 10, 10, 10, 10, 0)
self.assertEqual(video.get_window_position(window), (10, 10))
video.set_window_position(window, 0, 0)
self.assertEqual(video.get_window_position(window), (0, 0))
video.set_window_position(window, 600, 900)
self.assertEqual(video.get_window_position(window), (600, 900))
video.set_window_position(window, -200, -10)
self.assertEqual(video.get_window_position(window), (-200, -10))
video.destroy_window(window)
def test_get_window_pixelformat(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
fmt = video.get_window_pixelformat(window)
self.assertTrue(type(fmt) in(int, long))
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_pixelformat,
window)
def test_get_window_surface(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
for flag in flags:
window = video.create_window("Test", 200, 200, 200, 200, flag)
sf = video.get_window_surface(window)
self.assertIsInstance(sf, surface.SDL_Surface)
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_surface, window)
def test_raise_window(self):
window = video.create_window("test_raise_window", 200, 200, 200, 200,
0)
video.show_window(window)
doprint("""Please check, that a window with the title
'test_raise_window' is shown""")
doprint("Move another window on top of the window, so it is hidden")
video.raise_window(window)
doprint("The window should be raised to the foreground now")
video.destroy_window(window)
def test_hide_window(self):
window = video.create_window("test_hide_window", 200, 200, 200, 200, 0)
video.show_window(window)
doprint("""Please check, if a window with the title
'test_hide_window' is shown""")
video.hide_window(window)
doprint("Please check, that the window is not shown anymore")
video.show_window(window)
doprint("Please check, if the window is shown again")
video.destroy_window(window)
def test_get_set_window_size(self):
flags = video.SDL_WINDOW_BORDERLESS
window = video.create_window("Test", 10, 10, 10, 10, flags)
self.assertEqual(video.get_window_size(window), (10, 10))
video.set_window_size(window, 0, 0)
self.assertEqual(video.get_window_size(window), (0, 0))
video.set_window_size(window, 600, 900)
self.assertEqual(video.get_window_size(window), (600, 900))
video.set_window_size(window, -200, -10)
self.assertEqual(video.get_window_size(window), (-200, -10))
video.destroy_window(window)
def test_create_destroy_texture(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
formats = (pixels.SDL_PIXELFORMAT_ARGB8888,
pixels.SDL_PIXELFORMAT_RGB555,
pixels.SDL_PIXELFORMAT_RGBA4444,
pixels.SDL_PIXELFORMAT_RGBA8888,
pixels.SDL_PIXELFORMAT_ARGB2101010,
pixels.SDL_PIXELFORMAT_YUY2
)
access = (render.SDL_TEXTUREACCESS_STATIC,
render.SDL_TEXTUREACCESS_STREAMING,
render.SDL_TEXTUREACCESS_TARGET)
for fmt in formats:
for acc in access:
for w in range(1, 300, 5):
for h in range(1, 300, 5):
tex = render.create_texture(renderer, fmt, acc, w, h)
self.assertIsInstance(tex, render.SDL_Texture)
render.destroy_texture(tex)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, -10, 10)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, -10)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, -10, -10)
self.assertRaises(ValueError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, -5, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
-10, 1, 10, 10)
self.assertRaises((AttributeError, TypeError),
render.create_texture, None,
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
self.assertRaises((AttributeError, TypeError),
render.create_texture, "Test",
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
"Test", 1, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, None, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, "Test", 10, 10)
render.destroy_renderer(renderer)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
video.destroy_window(window)
def test_get_keyboard_focus(self):
window = keyboard.get_keyboard_focus()
self.assertEqual(window, None)
rwin = video.create_window("", 10, 10, 10, 10, 0)
window = keyboard.get_keyboard_focus()
if window:
self.assertEqual(video.get_window_id(window),
video.get_window_id(rwin))
video.destroy_window(rwin)
window = keyboard.get_keyboard_focus()
self.assertEqual(window, None)
def test_create_window(self):
# Borderless to ensure that the size check works
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
self.assertEqual(video.get_window_position(window), (10, 10))
self.assertEqual(video.get_window_size(window), (10, 10))
self.assertEqual(video.get_window_flags(window) & flag, flag)
self.assertEqual(video.get_window_title(window), "Test")
video.destroy_window(window)
def test_update_window_surface_rects(self):
rectlist = [rect.SDL_Rect(), rect.SDL_Rect(10, 10, 10, 10),
rect.SDL_Rect(0, 0, 5, 4), rect.SDL_Rect(-5, -5, 6, 2)]
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
for flag in flags:
window = video.create_window("Test", 200, 200, 200, 200, flag)
self.assertRaises(sdl.SDLError, video.update_window_surface_rects,
window, rectlist)
surface = video.get_window_surface(window)
video.update_window_surface_rects(window, rectlist)
video.destroy_window(window)
def test_render_target_supported(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
for i in range(render.get_num_render_drivers()):
renderer = render.create_renderer(window, i,
render.SDL_RENDERER_ACCELERATED)
self.assertIsInstance(renderer, render.SDL_Renderer)
val = render.render_target_supported(renderer)
self.assertIsInstance(val, bool)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_is_shaped_window(self):
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
window = shape.create_shaped_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
val = shape.is_shaped_window(window)
self.assertTrue(val)
video.destroy_window(window)
window = video.create_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
val = shape.is_shaped_window(window)
self.assertFalse(val)
video.destroy_window(window)
