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

pyglet/config/gl/windows.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import warnings
+from ctypes import c_int, c_uint, sizeof, byref
+from dataclasses import asdict
+
+from typing import TYPE_CHECKING
+from pyglet.config.gl import GLSurfaceConfig
+from pyglet.libs.win32 import PIXELFORMATDESCRIPTOR, _gdi32, wglext_arb, wgl
+from pyglet.libs.win32.constants import PFD_DRAW_TO_WINDOW, PFD_SUPPORT_OPENGL, PFD_DOUBLEBUFFER, \
+    PFD_DOUBLEBUFFER_DONTCARE, PFD_STEREO, PFD_STEREO_DONTCARE, PFD_DEPTH_DONTCARE, PFD_TYPE_RGBA
+from pyglet.libs.win32.wgl import WGLFunctions
+from pyglet.util import asstr
+
+if TYPE_CHECKING:
+    from pyglet.config import OpenGLConfig
+    from pyglet.window.win32 import Win32Window
+    from pyglet.graphics.api import OpenGLBackend
+    from pyglet.graphics.api.gl.win32.context import Win32ARBContext, Win32Context
+
+
+class _WGL:
+    """This is a staging area for WGL function loading.
+
+    WGL requires a context to be active before many functions can be called. Paradoxically, to create a WGL context,
+    another context has to already exist. Therefore, a bare temporary context is created and then destroyed after WGL
+    proc addresses are loaded and stored.
+    """
+    def __init__(self):
+        self._funcs = None
+        self._loaded = False
+        self._extensions = []
+
+    @property
+    def funcs(self):
+        return self._funcs
+
+    @property
+    def loaded(self) -> bool:
+        return self._loaded
+
+    def have_extension(self, extension: str) -> bool:
+        return extension in self._extensions
+
+    def create(self) -> bool:
+        from pyglet.window import _shadow_window  # noqa: PLC0415
+        funcs = self._initialize_wgl_funcs(_shadow_window)
+        if funcs:
+            self._loaded = True
+            self._funcs = funcs
+            self._extensions = asstr(funcs.wglGetExtensionsStringEXT()).split()
+            return True
+
+        return False
+
+    def _initialize_wgl_funcs(self, shadow_window: Win32Window) -> WGLFunctions | None:
+        """Creates a temporary context, creates WGL functions to proc addresses, then destroys the context."""
+        pfd = PIXELFORMATDESCRIPTOR()
+        pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR)
+        pfd.nVersion = 1
+        pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER
+        pfd.iPixelType = PFD_TYPE_RGBA
+        pfd.cColorBits = 24
+
+        shadow_dc = shadow_window.dc
+        assert shadow_dc is not None
+
+        # !!! # Will break transparent windows if using the main visible window.
+        #  Must use the shadow window here as once a pixel format is set for a Window it cannot be altered.
+        pf = _gdi32.ChoosePixelFormat(shadow_dc, byref(pfd))
+        if pf:
+            if not _gdi32.SetPixelFormat(shadow_dc, pf, byref(pfd)):
+                warnings.warn("Unable to set pixel format.")
+                return None
+        else:
+            warnings.warn("Unable to find a pixel format.")
+            return None
+
+        dummy_ctx = wgl.wglCreateContext(shadow_dc)
+        if not dummy_ctx:
+            warnings.warn("Unable to create dummy context.")
+            return None
+
+        current_dc = wgl.wglGetCurrentDC()
+        current_ctx = wgl.wglGetCurrentContext()
+
+        if not wgl.wglMakeCurrent(shadow_dc, dummy_ctx):
+            print("Unable to make dummy context current.")
+            # Set back to old context and dc and delete dummy context.
+            wgl.wglMakeCurrent(current_dc, current_ctx)
+            wgl.wglDeleteContext(dummy_ctx)
+            return None
+
+        funcs = WGLFunctions()
+        wgl.wglMakeCurrent(current_dc, current_ctx)
+        wgl.wglDeleteContext(dummy_ctx)
+        return funcs
+
+# A global WGL instance object that has retrieved all the proc addresses for WGL functions.
+_global_wgl = _WGL()
+
+def match(config: OpenGLConfig, window: Win32Window) -> GLSurfaceConfig | None:
+    if not _global_wgl.loaded:
+        _global_wgl.create()
+
+    if _global_wgl.have_extension('WGL_ARB_pixel_format'):
+         finalized_config = _get_arb_pixel_format_matching_configs(config, window)
+    else:
+        finalized_config = _get_pixel_format_descriptor_matching_configs(config, window)
+
+    return finalized_config
+
+def _get_pixel_format_descriptor_matching_configs(config: OpenGLConfig, window: Win32Window) -> GLLegacyConfig | None:
+    """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 config.double_buffer:
+        pfd.dwFlags |= PFD_DOUBLEBUFFER
+    else:
+        pfd.dwFlags |= PFD_DOUBLEBUFFER_DONTCARE
+
+    if config.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 config.depth_size:
+        pfd.dwFlags |= PFD_DEPTH_DONTCARE
+
+    pfd.iPixelType = PFD_TYPE_RGBA
+    pfd.cColorBits = config.buffer_size or 0
+    pfd.cRedBits = config.red_size or 0
+    pfd.cGreenBits = config.green_size or 0
+    pfd.cBlueBits = config.blue_size or 0
+    pfd.cAlphaBits = config.alpha_size or 0
+    pfd.cAccumRedBits = config.accum_red_size or 0
+    pfd.cAccumGreenBits = config.accum_green_size or 0
+    pfd.cAccumBlueBits = config.accum_blue_size or 0
+    pfd.cAccumAlphaBits = config.accum_alpha_size or 0
+    pfd.cDepthBits = config.depth_size or 0
+    pfd.cStencilBits = config.stencil_size or 0
+    pfd.cAuxBuffers = config.aux_buffers or 0
+
+    pf = _gdi32.ChoosePixelFormat(window.dc, byref(pfd))
+    if pf:
+        return GLLegacyConfig(window, pf, config)
+
+    return None
+
+def _get_arb_pixel_format_matching_configs(config: OpenGLConfig, window: Win32Window) -> GLSurfaceConfig | None:
+    """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 global_backend.have_extension('GL_ARB_multisample'):
+    #     return None
+
+    # Construct array of attributes
+    attrs = []
+    for name, value in asdict(config).items():
+        attr = GLSurfaceConfig.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)
+
+    _global_wgl.funcs.wglChoosePixelFormatARB(window.dc, attrs, None, nformats, pformats, nformats)
+
+    # Only choose the first format, because these are in order of best matching from driver.
+    # (Maybe not always the case?)
+    if pformats[0]:
+        pf = pformats[:nformats.value][0]
+        m =GLSurfaceConfig(window, pf, config)
+        return m
+
+    return None
+
+
+
+class GLLegacyConfig(GLSurfaceConfig):
+    def __init__(self, window: Win32Window, pf: int, user_config: OpenGLConfig) -> None:
+        super().__init__(window, user_config, pf)
+        self._pf = pf
+        self._pfd = PIXELFORMATDESCRIPTOR()
+
+        _gdi32.DescribePixelFormat(window.dc, 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 apply_format(self) -> None:
+        _gdi32.SetPixelFormat(self._window.dc, self._pf, byref(self._pfd))
+
+    def create_context(self, opengl_backend: OpenGLBackend, share: Win32ARBContext | None) -> Win32ARBContext | Win32Context:
+        from pyglet.graphics.api.gl.win32.context import Win32Context  # noqa: PLC0415
+        return Win32Context(opengl_backend, self._window, self, share)
+
+
+class GLSurfaceConfig(GLSurfaceConfig):
+    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, window: Win32Window, pf: int, user_config: OpenGLConfig) -> None:
+        super().__init__(window, user_config, pf)
+        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))()
+        _global_wgl.funcs.wglGetPixelFormatAttribivARB(window.dc, pf, 0, len(attrs), attrs, values)
+
+        for name, value in zip(names, values):
+            setattr(self, name, value)
+
+    def apply_format(self) -> None:
+        _gdi32.SetPixelFormat(self._window.dc, self._pf, None)
+
+    def create_context(
+        self, opengl_backend: OpenGLBackend, share: Win32ARBContext | None,
+    ) -> Win32ARBContext | Win32Context:
+        #super().create_context(opengl_backend, share)
+        from pyglet.graphics.api.gl.win32.context import Win32ARBContext, Win32Context  # noqa: PLC0415
+        if _global_wgl.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(opengl_backend, self._window, self, share)
+
+        return Win32Context(opengl_backend, self._window, self, share)

pyglet/config/gl/x11.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import NoReturn, TYPE_CHECKING
+
+from ctypes import c_int, cast, byref, POINTER, _Pointer
+
+from pyglet.libs.linux.glx import glx
+from pyglet.libs.linux.x11 import xlib
+from pyglet.libs.linux.x11.xrender import XRenderFindVisualFormat
+from pyglet.config import SurfaceConfig
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl.xlib.context import XlibContext
+    from pyglet.graphics.api import OpenGLBackend
+    from pyglet.config import OpenGLConfig
+    from pyglet.graphics.api.gl.xlib import glx_info
+    from pyglet.window.xlib import XlibWindow
+
+
+def match(config: OpenGLConfig, window: XlibWindow) -> XlibGLSurfaceConfig | None:
+    x_display = window._x_display  # noqa: SLF001
+    x_screen = window._x_screen_id  # noqa: SLF001
+
+    # Construct array of attributes
+    attrs = []
+    for name, value in asdict(config).items():
+        attr = XlibGLSurfaceConfig.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 None
+
+    configs = cast(configs, POINTER(glx.GLXFBConfig * elements.value)).contents
+
+    result = [XlibGLSurfaceConfig(window, c, config) for c in configs]
+
+    # If we intend to have a transparent framebuffer.
+    if config.transparent_framebuffer:
+        result = [fb_cf for fb_cf in result if fb_cf.transparent]
+
+    # If we intend to have a transparent framebuffer.
+    if config.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[0]
+
+
+class XlibGLSurfaceConfig(SurfaceConfig):
+    _glx_info: 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,
+        # 'drawable_type': glx.GLX_DRAWABLE_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, window: XlibWindow, fbconfig: glx.GLXFBConfig,
+                 config: OpenGLConfig) -> None:
+        super().__init__(window, config, fbconfig)
+
+        self.fbconfig = fbconfig
+        self.transparent = False
+
+        for name, attr in self.attribute_ids.items():
+            value = c_int()
+            result = glx.glXGetFBConfigAttrib(self._window._x_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(self._window._x_display, self.fbconfig)  # noqa: SLF001
+            if xvi_ptr:
+                self.transparent = window._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._window._x_display, self.fbconfig).contents  # noqa: SLF001
+
+    def create_context(self, opengl_backend: OpenGLBackend, share: XlibContext | None) -> XlibContext:
+        from pyglet.graphics.api.gl.xlib.context import XlibContext  # noqa: PLC0415
+        return XlibContext(opengl_backend, self._window, self, share)
+
+    def _create_glx_context(self, _share: None) -> NoReturn:
+        raise NotImplementedError
+
+    def apply_format(self) -> None:
+        pass
+
+    def is_complete(self) -> bool:
+        return True

pyglet/customtypes.py

@@ -1,9 +1,11 @@
 """Holds type aliases used throughout the codebase."""
+from __future__ import annotations
 import ctypes
 import sys
 
-from typing import Union, Literal
+from typing import Union, Literal, Type, Protocol, Tuple
 
+from ctypes import _SimpleCData, _Pointer  # type: ignore  # noqa: PGH003
 
 if sys.version_info >= (3, 12):
     from collections.abc import Buffer
@@ -16,8 +18,47 @@ AnchorX = Literal["left", "center", "right"]
 AnchorY = Literal["top", "bottom", "center", "baseline"]
 ContentVAlign = Literal["bottom", "center", "top"]
 
+Number = Union[int, float]
+
+RGBColor = Tuple[Number, Number, Number]
+RGBAColor = Tuple[Number, Number, Number, Number]
+
+DataTypes = Literal[
+    'f',  # float
+    'i',  # int
+    'I',  # unsigned int
+    'h',  # short
+    'H',  # unsigned short
+    'b',  # byte
+    'B',  # unsigned byte
+    'q',  # long long
+    'Q',  # unsigned long long
+    '?',  # bool
+    'd',  # double
+]
+
+CType = Type[_SimpleCData]
+CTypesPointer = _Pointer
+
+
+
+class ScissorProtocol(Protocol):
+    x: int
+    y: int
+    width: int
+    height: int
+
 
 
 __all__ = [
-    "Buffer", "HorizontalAlign", "AnchorX", "AnchorY", "ContentVAlign"
+    "AnchorX",
+    "AnchorY",
+    "Buffer",
+    "CType",
+    "CTypesPointer",
+    "ContentVAlign",
+    "DataTypes",
+    "HorizontalAlign",
+    "RGBAColor",
+    "RGBColor",
 ]

pyglet/display/__init__.py

@@ -29,25 +29,27 @@ _is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
 
 if _is_pyglet_doc_run:
-    from pyglet.display.base import Display, Screen, Canvas, ScreenMode
+    from pyglet.display.base import Display, Screen, ScreenMode
 else:
     from pyglet import compat_platform, options
     if options['headless']:
         from pyglet.display.headless import HeadlessDisplay as Display
         from pyglet.display.headless import HeadlessScreen as Screen
-        from pyglet.display.headless import HeadlessCanvas as Canvas
     elif compat_platform == 'darwin':
         from pyglet.display.cocoa import CocoaDisplay as Display
         from pyglet.display.cocoa import CocoaScreen as Screen
-        from pyglet.display.cocoa import CocoaCanvas as Canvas
     elif compat_platform in ('win32', 'cygwin'):
         from pyglet.display.win32 import Win32Display as Display
         from pyglet.display.win32 import Win32Screen as Screen
-        from pyglet.display.win32 import Win32Canvas as Canvas
+    elif compat_platform == 'linux' and options.wayland:
+        from pyglet.display.wayland import WaylandDisplay as Display
+        from pyglet.display.wayland import WaylandScreen as Screen
     elif compat_platform == 'linux':
         from pyglet.display.xlib import XlibDisplay as Display
         from pyglet.display.xlib import XlibScreen as Screen
-        from pyglet.display.xlib import XlibCanvas as Canvas
+    elif compat_platform == 'emscripten':
+        from pyglet.display.emscripten import EmscriptenDisplay as Display
+        from pyglet.display.emscripten import EmscriptenScreen as Screen
     else:
         msg = f"A display interface for '{compat_platform}' is not yet implemented."
         raise NotImplementedError(msg)
@@ -77,4 +79,4 @@ def get_display() -> Display:
     return Display()
 
 
-__all__ = ['Display', 'Screen', 'Canvas', 'ScreenMode', 'get_display']
+__all__ = ['Display', 'Screen', 'ScreenMode', 'get_display']

pyglet/display/base.py

@@ -3,10 +3,9 @@ from __future__ import annotations
 import abc
 from typing import TYPE_CHECKING, Literal
 
-from pyglet import app, display, gl, window
+from pyglet import app, display
 
 if TYPE_CHECKING:
-    from pyglet.gl import Config
     from pyglet.window import BaseWindow
 
 
@@ -26,8 +25,8 @@ class Display:
         default is usually ``":1"``.  On X11, :attr:`x_screen` gives the X 
         screen number to use with this display.  A pyglet display can only be 
         used with one X screen; open multiple display connections to access
-        multiple X screens.  
-        
+        multiple X screens.
+
         Note that TwinView, Xinerama, xrandr and other extensions present
         multiple monitors on a single X screen; this is usually the preferred
         mechanism for working with multiple monitors under X11 and allows each
@@ -100,52 +99,6 @@ class Screen(abc.ABC):
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(x={self.x}, y={self.y}, width={self.width}, height={self.height})"
 
-    def get_best_config(self, template: Config = None) -> Config:
-        """Get the best available GL config.
-
-        Any required attributes can be specified in ``template``.  If
-        no configuration matches the template,
-        :class:`~pyglet.window.NoSuchConfigException` will be raised.
-        A configuration supported by the platform that best fulfils
-        the needs described by the template.
-
-        :deprecated: Use :meth:`pyglet.gl.Config.match`.
-
-        Args:
-            template:
-                A configuration with desired attributes filled in.
-        """
-        configs = None
-        if template is None:
-            for template_config in [gl.Config(double_buffer=True, depth_size=24, major_version=3, minor_version=3),
-                                    gl.Config(double_buffer=True, depth_size=16, major_version=3, minor_version=3),
-                                    None]:
-                try:
-                    configs = self.get_matching_configs(template_config)
-                    break
-                except window.NoSuchConfigException:
-                    pass
-        else:
-            configs = self.get_matching_configs(template)
-        if not configs:
-            raise window.NoSuchConfigException()
-        return configs[0]
-
-    def get_matching_configs(self, template: Config) -> list[Config]:
-        """Get a list of configs that match a specification.
-
-        Any attributes specified in `template` will have values equal
-        to or greater in each returned config.  If no configs satisfy
-        the template, an empty list is returned.
-
-        :deprecated: Use :meth:`pyglet.gl.Config.match`.
-
-        Args:
-            template:
-                A configuration with desired attributes filled in.
-        """
-        raise NotImplementedError('abstract')
-
     def get_modes(self) -> list[ScreenMode]:
         """Get a list of screen modes supported by this screen.
 
@@ -273,16 +226,3 @@ class ScreenMode:
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}(width={self.width!r}, height={self.height!r}, depth={self.depth!r}, rate={self.rate})'
 
-
-class Canvas:
-    """Abstract drawing area.
-
-    Canvases are used internally by pyglet to represent drawing areas --
-    either within a window or full-screen.
-
-    .. versionadded:: 1.2
-    """
-
-    def __init__(self, display: Display) -> None:
-        self.display = display
-        """Display this canvas was created on."""

pyglet/display/cocoa.py

@@ -1,13 +1,20 @@
 # Note: The display mode API used here is Mac OS 10.6 only.
 from __future__ import annotations
 
-from ctypes import c_uint32, c_void_p, byref
+from ctypes import byref, c_uint32, c_void_p
 
-from .base import Canvas, Display, Screen, ScreenMode
-from pyglet.libs.darwin.cocoapy import CGDirectDisplayID, quartz, cf, ObjCClass, get_NSString
-from pyglet.libs.darwin.cocoapy import cfstring_to_string, cfarray_to_list
 from pyglet.libs.darwin import NSDeviceResolution
-
+from pyglet.libs.darwin.cocoapy import (
+    CGDirectDisplayID,
+    ObjCClass,
+    cf,
+    cfarray_to_list,
+    cfstring_to_string,
+    get_NSString,
+    quartz,
+)
+
+from .base import Display, Screen, ScreenMode
 
 NSScreen = ObjCClass('NSScreen')
 
@@ -82,10 +89,6 @@ class CocoaScreen(Screen):
 
         return ratio
 
-    def get_matching_configs(self, template):
-        canvas = CocoaCanvas(self.display, self, None)
-        return template.match(canvas)
-
     def get_modes(self):
         cgmodes = c_void_p(quartz.CGDisplayCopyAllDisplayModes(self._cg_display_id, None))
         modes = [CocoaScreenMode(self, cgmode) for cgmode in cfarray_to_list(cgmodes)]
@@ -161,11 +164,3 @@ class CocoaScreenMode(ScreenMode):
         if pixelEncoding == IO16BitDirectPixels: return 16
         if pixelEncoding == IO32BitDirectPixels: return 32
         return 0
-
-
-class CocoaCanvas(Canvas):
-
-    def __init__(self, display, screen, nsview):
-        super().__init__(display)
-        self.screen = screen
-        self.nsview = nsview

pyglet/display/emscripten.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pyglet.display.base import Display, Screen
+import js
+
+class EmscriptenDisplay(Display):
+
+    def __init__(self):
+        super().__init__()
+
+    def get_screens(self):
+        return [EmscriptenScreen(self)]
+
+
+class EmscriptenScreen(Screen):
+    def __init__(self, display: EmscriptenDisplay):
+        width = js.window.screen.width
+        height = js.window.screen.height
+        super().__init__(display, 0, 0, width, height)
+
+    def get_display_id(self) -> int:
+        return 0
+
+    def get_monitor_name(self) -> str | Literal["Unknown"]:
+        return "BROWSER"
+
+    def get_modes(self):
+        pass
+
+    def get_mode(self):
+        pass
+
+    def set_mode(self, mode):
+        pass
+
+    def restore_mode(self):
+        pass