pyglet 2.1.13__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/gl/win32.py

@@ -1,268 +0,0 @@
-from __future__ import annotations
-
-from ctypes import byref, c_int, c_uint, sizeof
-
-from pyglet import gl
-from pyglet.display.win32 import Win32Canvas
-from pyglet.gl import gl_info, wgl, wgl_info, wglext_arb
-from pyglet.libs.win32 import PIXELFORMATDESCRIPTOR, _gdi32
-from pyglet.libs.win32.constants import (
-    PFD_DEPTH_DONTCARE,
-    PFD_DOUBLEBUFFER,
-    PFD_DOUBLEBUFFER_DONTCARE,
-    PFD_DRAW_TO_WINDOW,
-    PFD_STEREO,
-    PFD_STEREO_DONTCARE,
-    PFD_SUPPORT_OPENGL,
-    PFD_TYPE_RGBA,
-)
-
-from .base import DisplayConfig, Config, Context
-
-
-class Win32Config(Config):  # noqa: D101
-
-    def match(self, canvas: Win32Canvas) -> list[Win32DisplayConfig] | list[Win32DisplayConfigARB]:
-        if not isinstance(canvas, Win32Canvas):
-            msg = 'Canvas must be instance of Win32Canvas'
-            raise RuntimeError(msg)
-
-        # Use ARB API if available
-        if gl_info.have_context() and wgl_info.have_extension('WGL_ARB_pixel_format'):
-            return self._get_arb_pixel_format_matching_configs(canvas)
-
-        return self._get_pixel_format_descriptor_matching_configs(canvas)
-
-    def _get_pixel_format_descriptor_matching_configs(self, canvas: Win32Canvas) -> list[Win32DisplayConfig]:
-        """Get matching configs using standard PIXELFORMATDESCRIPTOR technique."""
-        pfd = PIXELFORMATDESCRIPTOR()
-        pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR)
-        pfd.nVersion = 1
-        pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL
-
-        if self.double_buffer:
-            pfd.dwFlags |= PFD_DOUBLEBUFFER
-        else:
-            pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE
-
-        if self.stereo:
-            pfd.dwFlags |= PFD_STEREO
-        else:
-            pfd.dwFlags |= PFD_STEREO_DONTCARE
-
-        #  Not supported in pyglet API: swap_copy: PFD_SWAP_COPY and swap_exchange: PFD_SWAP_EXCHANGE
-
-        if not self.depth_size:
-            pfd.dwFlags |= PFD_DEPTH_DONTCARE
-
-        pfd.iPixelType = PFD_TYPE_RGBA
-        pfd.cColorBits = self.buffer_size or 0
-        pfd.cRedBits = self.red_size or 0
-        pfd.cGreenBits = self.green_size or 0
-        pfd.cBlueBits = self.blue_size or 0
-        pfd.cAlphaBits = self.alpha_size or 0
-        pfd.cAccumRedBits = self.accum_red_size or 0
-        pfd.cAccumGreenBits = self.accum_green_size or 0
-        pfd.cAccumBlueBits = self.accum_blue_size or 0
-        pfd.cAccumAlphaBits = self.accum_alpha_size or 0
-        pfd.cDepthBits = self.depth_size or 0
-        pfd.cStencilBits = self.stencil_size or 0
-        pfd.cAuxBuffers = self.aux_buffers or 0
-
-        pf = _gdi32.ChoosePixelFormat(canvas.hdc, byref(pfd))
-        if pf:
-            return [Win32DisplayConfig(canvas, pf, self)]
-        else:
-            return []
-
-    def _get_arb_pixel_format_matching_configs(self, canvas: Win32Canvas) -> list[Win32DisplayConfigARB]:
-        """Get configs using the WGL_ARB_pixel_format extension.
-
-        This method assumes a (dummy) GL context is already created.
-        """
-        # Check for required extensions
-        if (self.sample_buffers or self.samples) and not gl_info.have_extension('GL_ARB_multisample'):
-            return []
-
-        # Construct array of attributes
-        attrs = []
-        for name, value in self.get_gl_attributes():
-            attr = Win32DisplayConfigARB.attribute_ids.get(name, None)
-            if attr and value is not None:
-                attrs.extend([attr, int(value)])
-        attrs.append(0)
-        attrs = (c_int * len(attrs))(*attrs)
-
-        pformats = (c_int * 16)()
-        nformats = c_uint(16)
-        wglext_arb.wglChoosePixelFormatARB(canvas.hdc, attrs, None, nformats, pformats, nformats)
-
-        formats = [Win32DisplayConfigARB(canvas, pf, self) for pf in pformats[:nformats.value]]
-        return formats
-
-
-class Win32DisplayConfig(DisplayConfig):  # noqa: D101
-    def __init__(self, canvas: Win32Canvas, pf: int, config: Win32Config) -> None:  # noqa: D107
-        super().__init__(canvas, config)
-        self._pf = pf
-        self._pfd = PIXELFORMATDESCRIPTOR()
-
-        _gdi32.DescribePixelFormat(canvas.hdc, pf, sizeof(PIXELFORMATDESCRIPTOR), byref(self._pfd))
-
-        self.double_buffer = bool(self._pfd.dwFlags & PFD_DOUBLEBUFFER)
-        self.sample_buffers = 0
-        self.samples = 0
-        self.stereo = bool(self._pfd.dwFlags & PFD_STEREO)
-        self.buffer_size = self._pfd.cColorBits
-        self.red_size = self._pfd.cRedBits
-        self.green_size = self._pfd.cGreenBits
-        self.blue_size = self._pfd.cBlueBits
-        self.alpha_size = self._pfd.cAlphaBits
-        self.accum_red_size = self._pfd.cAccumRedBits
-        self.accum_green_size = self._pfd.cAccumGreenBits
-        self.accum_blue_size = self._pfd.cAccumBlueBits
-        self.accum_alpha_size = self._pfd.cAccumAlphaBits
-        self.depth_size = self._pfd.cDepthBits
-        self.stencil_size = self._pfd.cStencilBits
-        self.aux_buffers = self._pfd.cAuxBuffers
-
-    def compatible(self, canvas: Win32Canvas) -> bool:
-        return isinstance(canvas, Win32Canvas)
-
-    def create_context(self, share: Win32Context | None) -> Win32Context:
-        return Win32Context(self, share)
-
-    def _set_pixel_format(self, canvas: Win32Canvas) -> None:
-        _gdi32.SetPixelFormat(canvas.hdc, self._pf, byref(self._pfd))
-
-
-class Win32DisplayConfigARB(DisplayConfig):  # noqa: D101
-    attribute_ids = {  # noqa: RUF012
-        'double_buffer': wglext_arb.WGL_DOUBLE_BUFFER_ARB,
-        'stereo': wglext_arb.WGL_STEREO_ARB,
-        'buffer_size': wglext_arb.WGL_COLOR_BITS_ARB,
-        'aux_buffers': wglext_arb.WGL_AUX_BUFFERS_ARB,
-        'sample_buffers': wglext_arb.WGL_SAMPLE_BUFFERS_ARB,
-        'samples': wglext_arb.WGL_SAMPLES_ARB,
-        'red_size': wglext_arb.WGL_RED_BITS_ARB,
-        'green_size': wglext_arb.WGL_GREEN_BITS_ARB,
-        'blue_size': wglext_arb.WGL_BLUE_BITS_ARB,
-        'alpha_size': wglext_arb.WGL_ALPHA_BITS_ARB,
-        'depth_size': wglext_arb.WGL_DEPTH_BITS_ARB,
-        'stencil_size': wglext_arb.WGL_STENCIL_BITS_ARB,
-        'accum_red_size': wglext_arb.WGL_ACCUM_RED_BITS_ARB,
-        'accum_green_size': wglext_arb.WGL_ACCUM_GREEN_BITS_ARB,
-        'accum_blue_size': wglext_arb.WGL_ACCUM_BLUE_BITS_ARB,
-        'accum_alpha_size': wglext_arb.WGL_ACCUM_ALPHA_BITS_ARB,
-    }
-
-    def __init__(self, canvas: Win32Canvas, pf: int, config: Win32Config) -> None:  # noqa: D107
-        super().__init__(canvas, config)
-        self._pf = pf
-
-        names = list(self.attribute_ids.keys())
-        attrs = list(self.attribute_ids.values())
-        attrs = (c_int * len(attrs))(*attrs)
-        values = (c_int * len(attrs))()
-
-        wglext_arb.wglGetPixelFormatAttribivARB(canvas.hdc, pf, 0, len(attrs), attrs, values)
-
-        for name, value in zip(names, values):
-            setattr(self, name, value)
-
-    def compatible(self, canvas: Win32Canvas) -> bool:
-        # TODO more careful checking
-        return isinstance(canvas, Win32Canvas)
-
-    def create_context(self, share: Win32ARBContext | None) -> Win32ARBContext | Win32Context:
-        if wgl_info.have_extension('WGL_ARB_create_context'):
-            # Graphics adapters that ONLY support up to OpenGL 3.1/3.2
-            # should be using the Win32ARBContext class.
-            return Win32ARBContext(self, share)
-
-        return Win32Context(self, share)
-
-    def _set_pixel_format(self, canvas: Win32Canvas) -> None:
-        _gdi32.SetPixelFormat(canvas.hdc, self._pf, None)
-
-
-class _BaseWin32Context(Context):
-    def __init__(self, config: Win32DisplayConfig | Win32DisplayConfigARB, share: Win32Context | Win32ARBContext) -> None:
-        super().__init__(config, share)
-        self._context = None
-
-    def set_current(self) -> None:
-        if self._context is not None and self != gl.current_context:
-            wgl.wglMakeCurrent(self.canvas.hdc, self._context)
-        super().set_current()
-
-    def detach(self) -> None:
-        if self.canvas:
-            wgl.wglDeleteContext(self._context)
-            self._context = None
-        super().detach()
-
-    def flip(self) -> None:
-        _gdi32.SwapBuffers(self.canvas.hdc)
-
-    def get_vsync(self) -> bool:
-        if wgl_info.have_extension('WGL_EXT_swap_control'):
-            return bool(wglext_arb.wglGetSwapIntervalEXT())
-        return False
-
-    def set_vsync(self, vsync: bool) -> None:
-        if wgl_info.have_extension('WGL_EXT_swap_control'):
-            wglext_arb.wglSwapIntervalEXT(int(vsync))
-
-
-class Win32Context(_BaseWin32Context):  # noqa: D101
-    config: Win32DisplayConfig
-    context_share: Win32Context | None
-
-    def attach(self, canvas: Win32Canvas) -> None:
-        super().attach(canvas)
-
-        if not self._context:
-            self.config._set_pixel_format(canvas)  # noqa: SLF001
-            self._context = wgl.wglCreateContext(canvas.hdc)
-
-        share = self.context_share
-        if share:
-            if not share.canvas:
-                msg = 'Share context has no canvas.'
-                raise RuntimeError(msg)
-            if not wgl.wglShareLists(share._context, self._context):  # noqa: SLF001
-                msg = 'Unable to share contexts.'
-                raise gl.ContextException(msg)
-
-
-class Win32ARBContext(_BaseWin32Context):  # noqa: D101
-    config: Win32DisplayConfigARB
-    context_share: Win32ARBContext | None
-
-    def attach(self, canvas: Win32Canvas) -> None:
-        share = self.context_share
-        if share:
-            if not share.canvas:
-                msg = 'Share context has no canvas.'
-                raise RuntimeError(msg)
-            share = share._context  # noqa: SLF001
-
-        attribs = []
-        if self.config.major_version is not None:
-            attribs.extend([wglext_arb.WGL_CONTEXT_MAJOR_VERSION_ARB, self.config.major_version])
-        if self.config.minor_version is not None:
-            attribs.extend([wglext_arb.WGL_CONTEXT_MINOR_VERSION_ARB, self.config.minor_version])
-        flags = 0
-        if self.config.forward_compatible:
-            flags |= wglext_arb.WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
-        if self.config.debug:
-            flags |= wglext_arb.WGL_CONTEXT_DEBUG_BIT_ARB
-        if flags:
-            attribs.extend([wglext_arb.WGL_CONTEXT_FLAGS_ARB, flags])
-        attribs.append(0)
-        attribs = (c_int * len(attribs))(*attribs)
-
-        self.config._set_pixel_format(canvas)  # noqa: SLF001
-        self._context = wglext_arb.wglCreateContextAttribsARB(canvas.hdc, share, attribs)
-        super().attach(canvas)

pyglet/gl/xlib.py

@@ -1,295 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from _ctypes import _Pointer
-from ctypes import POINTER, byref, c_int, c_uint, cast
-from typing import TYPE_CHECKING, NoReturn
-
-from pyglet import gl
-from pyglet.gl import glx
-from pyglet.gl import glxext_arb
-from pyglet.gl import glx_info
-from pyglet.gl import glxext_mesa
-from pyglet.gl import lib
-from pyglet.gl.base import Config, DisplayConfig, Context
-
-from pyglet.display.xlib import XlibCanvas
-from pyglet.libs.x11 import xlib
-from pyglet.libs.x11.xrender import XRenderFindVisualFormat
-
-if TYPE_CHECKING:
-    from pyglet.libs.x11.xlib import Display
-    from .glx_info import GLXInfo
-
-
-class XlibConfig(Config):  # noqa: D101
-
-    def match(self, canvas: XlibCanvas) -> list[XlibDisplayConfig]:
-        if not isinstance(canvas, XlibCanvas):
-            msg = f'Canvas must be an instance of XlibCanvas {type(canvas)}'
-            raise RuntimeError(msg)
-
-        x_display = canvas.display._display  # noqa: SLF001
-        x_screen = canvas.display.x_screen
-
-        info = glx_info.GLXInfo(x_display)
-
-        # Construct array of attributes
-        attrs = []
-        for name, value in self.get_gl_attributes():
-            attr = XlibDisplayConfig.attribute_ids.get(name, None)
-            if attr and value is not None:
-                attrs.extend([attr, int(value)])
-
-        attrs.extend([glx.GLX_X_RENDERABLE, True])
-        attrs.extend([0, 0])  # attrib_list must be null terminated
-
-        attrib_list = (c_int * len(attrs))(*attrs)
-
-        elements = c_int()
-        configs = glx.glXChooseFBConfig(x_display, x_screen, attrib_list, byref(elements))
-        if not configs:
-            return []
-
-        configs = cast(configs, POINTER(glx.GLXFBConfig * elements.value)).contents
-
-        result = [XlibDisplayConfig(canvas, info, c, self) for c in configs]
-
-        # If we intend to have a transparent framebuffer.
-        if self.transparent_framebuffer:
-            result = [fb_cf for fb_cf in result if fb_cf.transparent]
-
-        # Can't free array until all XlibGLConfig's are GC'd.  Too much
-        # hassle, live with leak. XXX
-        # xlib.XFree(configs)
-
-        return result
-
-
-class XlibDisplayConfig(DisplayConfig):  # noqa: D101
-    glx_info: GLXInfo
-
-    attribute_ids = {  # noqa: RUF012
-        'buffer_size': glx.GLX_BUFFER_SIZE,
-        'level': glx.GLX_LEVEL,  # Not supported
-        'double_buffer': glx.GLX_DOUBLEBUFFER,
-        'stereo': glx.GLX_STEREO,
-        'aux_buffers': glx.GLX_AUX_BUFFERS,
-        'red_size': glx.GLX_RED_SIZE,
-        'green_size': glx.GLX_GREEN_SIZE,
-        'blue_size': glx.GLX_BLUE_SIZE,
-        'alpha_size': glx.GLX_ALPHA_SIZE,
-        'depth_size': glx.GLX_DEPTH_SIZE,
-        'stencil_size': glx.GLX_STENCIL_SIZE,
-        'accum_red_size': glx.GLX_ACCUM_RED_SIZE,
-        'accum_green_size': glx.GLX_ACCUM_GREEN_SIZE,
-        'accum_blue_size': glx.GLX_ACCUM_BLUE_SIZE,
-        'accum_alpha_size': glx.GLX_ACCUM_ALPHA_SIZE,
-
-        'sample_buffers': glx.GLX_SAMPLE_BUFFERS,
-        'samples': glx.GLX_SAMPLES,
-
-        # Not supported in current pyglet API:
-        'render_type': glx.GLX_RENDER_TYPE,
-        'config_caveat': glx.GLX_CONFIG_CAVEAT,
-        'transparent_type': glx.GLX_TRANSPARENT_TYPE,
-        'transparent_index_value': glx.GLX_TRANSPARENT_INDEX_VALUE,
-        'transparent_red_value': glx.GLX_TRANSPARENT_RED_VALUE,
-        'transparent_green_value': glx.GLX_TRANSPARENT_GREEN_VALUE,
-        'transparent_blue_value': glx.GLX_TRANSPARENT_BLUE_VALUE,
-        'transparent_alpha_value': glx.GLX_TRANSPARENT_ALPHA_VALUE,
-
-        # Used internally
-        'x_renderable': glx.GLX_X_RENDERABLE,
-    }
-
-    def __init__(self, canvas: XlibCanvas, info: GLXInfo, fbconfig: glx.GLXFBConfig,  # noqa: D107
-                 config: XlibConfig) -> None:
-        super().__init__(canvas, config)
-
-        self.glx_info = info
-        self.fbconfig = fbconfig
-        self.transparent = False
-
-        for name, attr in self.attribute_ids.items():
-            value = c_int()
-            result = glx.glXGetFBConfigAttrib(canvas.display._display, self.fbconfig, attr,  # noqa: SLF001
-                                              byref(value))
-            if result >= 0:
-                setattr(self, name, value.value)
-
-        # If user intends for a transparent framebuffer, the visual info needs to be
-        # queried for it. Even if a config supports alpha_size 8 and depth_size 32, there is no
-        # guarantee the visual info supports that same configuration.
-        if config.transparent_framebuffer:
-            xvi_ptr = glx.glXGetVisualFromFBConfig(canvas.display._display, self.fbconfig)  # noqa: SLF001
-            if xvi_ptr:
-                self.transparent = self._is_visual_transparent(xvi_ptr.contents.visual)  # noqa: SLF001
-                xlib.XFree(xvi_ptr)
-
-    def _is_visual_transparent(self, visual: _Pointer[xlib.Visual]) -> bool:
-        if not XRenderFindVisualFormat:
-            return False
-
-        xrender_format = XRenderFindVisualFormat(self.canvas.display._display, visual)
-        return xrender_format and xrender_format.contents.direct.alphaMask != 0
-
-    def get_visual_info(self) -> glx.XVisualInfo:
-        return glx.glXGetVisualFromFBConfig(self.canvas.display._display, self.fbconfig).contents  # noqa: SLF001
-
-    def create_context(self, share: XlibContext | None) -> XlibContext:
-        return XlibContext(self, share)
-
-    def compatible(self, canvas: XlibCanvas) -> bool:
-        # TODO check more
-        return isinstance(canvas, XlibCanvas)
-
-    def _create_glx_context(self, _share: None) -> NoReturn:
-        raise NotImplementedError
-
-    def is_complete(self) -> bool:
-        return True
-
-
-class XlibContext(Context):  # noqa: D101
-    x_display: Display
-    glx_context: glx.GLXContext
-    glx_window: glx.GLXWindow | None
-    _use_video_sync: bool
-    _vsync: bool
-    config: XlibDisplayConfig
-
-    _have_SGI_swap_control: bool  # noqa: N815
-    _have_EXT_swap_control: bool  # noqa: N815
-    _have_MESA_swap_control: bool  # noqa: N815
-    _have_SGI_video_sync: bool  # noqa: N815
-
-    def __init__(self, config: XlibDisplayConfig, share: XlibContext | None) -> None:  # noqa: D107
-        super().__init__(config, share)
-
-        self.x_display = config.canvas.display._display  # noqa: SLF001
-
-        self.glx_context = self._create_glx_context(share)
-        if not self.glx_context:
-            # TODO: Check Xlib error generated
-            msg = 'Could not create GL context'
-            raise gl.ContextException(msg)
-
-        self._have_SGI_video_sync = config.glx_info.have_extension('GLX_SGI_video_sync')
-        self._have_SGI_swap_control = config.glx_info.have_extension('GLX_SGI_swap_control')
-        self._have_EXT_swap_control = config.glx_info.have_extension('GLX_EXT_swap_control')
-        self._have_MESA_swap_control = config.glx_info.have_extension('GLX_MESA_swap_control')
-
-        # In order of preference:
-        # 1. GLX_EXT_swap_control (more likely to work where video_sync will not)
-        # 2. GLX_MESA_swap_control (same as above, but supported by MESA drivers)
-        # 3. GLX_SGI_video_sync (does not work on Intel 945GM, but that has EXT)
-        # 4. GLX_SGI_swap_control (cannot be disabled once enabled)
-        self._use_video_sync = (self._have_SGI_video_sync and
-                                not (self._have_EXT_swap_control or self._have_MESA_swap_control))
-
-        # XXX Mandate that vsync defaults on across all platforms.
-        self._vsync = True
-
-        self.glx_window = None
-
-    def is_direct(self) -> bool:
-        return bool(glx.glXIsDirect(self.x_display, self.glx_context))
-
-    def _create_glx_context(self, share: XlibContext | None) -> glx.GLXContext:
-        if share:
-            share_context = share.glx_context
-        else:
-            share_context = None
-
-        attribs = []
-        if self.config.major_version is not None:
-            attribs.extend([glxext_arb.GLX_CONTEXT_MAJOR_VERSION_ARB, self.config.major_version])
-        if self.config.minor_version is not None:
-            attribs.extend([glxext_arb.GLX_CONTEXT_MINOR_VERSION_ARB, self.config.minor_version])
-
-        if self.config.opengl_api == "gl":
-            attribs.extend([glxext_arb.GLX_CONTEXT_PROFILE_MASK_ARB, glxext_arb.GLX_CONTEXT_CORE_PROFILE_BIT_ARB])
-        elif self.config.opengl_api == "gles":
-            attribs.extend([glxext_arb.GLX_CONTEXT_PROFILE_MASK_ARB, glxext_arb.GLX_CONTEXT_ES2_PROFILE_BIT_EXT])
-
-        flags = 0
-        if self.config.forward_compatible:
-            flags |= glxext_arb.GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
-        if self.config.debug:
-            flags |= glxext_arb.GLX_CONTEXT_DEBUG_BIT_ARB
-
-        if flags:
-            attribs.extend([glxext_arb.GLX_CONTEXT_FLAGS_ARB, flags])
-        attribs.append(0)
-        attribs = (c_int * len(attribs))(*attribs)
-
-        return glxext_arb.glXCreateContextAttribsARB(self.config.canvas.display._display,  # noqa: SLF001
-                                                     self.config.fbconfig, share_context, True, attribs)
-
-    def attach(self, canvas: XlibCanvas) -> None:
-        if canvas is self.canvas:
-            return
-
-        super().attach(canvas)
-
-        self.glx_window = glx.glXCreateWindow(self.x_display, self.config.fbconfig, canvas.x_window, None)
-        self.set_current()
-
-    def set_current(self) -> None:
-        glx.glXMakeContextCurrent(self.x_display, self.glx_window, self.glx_window, self.glx_context)
-        super().set_current()
-
-    def detach(self) -> None:
-        if not self.canvas:
-            return
-
-        self.set_current()
-        gl.glFlush()
-
-        super().detach()
-
-        glx.glXMakeContextCurrent(self.x_display, 0, 0, None)
-        if self.glx_window:
-            glx.glXDestroyWindow(self.x_display, self.glx_window)
-            self.glx_window = None
-
-    def destroy(self) -> None:
-        super().destroy()
-        if self.glx_window:
-            glx.glXDestroyWindow(self.x_display, self.glx_window)
-            self.glx_window = None
-        if self.glx_context:
-            glx.glXDestroyContext(self.x_display, self.glx_context)
-            self.glx_context = None
-
-    def set_vsync(self, vsync: bool = True) -> None:
-        self._vsync = vsync
-        interval = vsync and 1 or 0
-        try:
-            if not self._use_video_sync and self._have_EXT_swap_control:
-                glxext_arb.glXSwapIntervalEXT(self.x_display, glx.glXGetCurrentDrawable(), interval)
-            elif not self._use_video_sync and self._have_MESA_swap_control:
-                glxext_mesa.glXSwapIntervalMESA(interval)
-            elif self._have_SGI_swap_control:
-                glxext_arb.glXSwapIntervalSGI(interval)
-        except lib.MissingFunctionException as e:
-            warnings.warn(str(e))
-
-    def get_vsync(self) -> bool:
-        return self._vsync
-
-    def _wait_vsync(self) -> None:
-        if self._vsync and self._have_SGI_video_sync and self._use_video_sync:
-            count = c_uint()
-            glxext_arb.glXGetVideoSyncSGI(byref(count))
-            glxext_arb.glXWaitVideoSyncSGI(2, (count.value + 1) % 2, byref(count))
-
-    def flip(self) -> None:
-        if not self.glx_window:
-            return
-
-        if self._vsync:
-            self._wait_vsync()
-
-        glx.glXSwapBuffers(self.x_display, self.glx_window)