pyglet 2.1.6__py3-none-any.whl → 2.1.8__py3-none-any.whl

pyglet/gl/xlib.py

@@ -1,6 +1,7 @@
 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
 
@@ -13,6 +14,8 @@ 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
@@ -52,6 +55,10 @@ class XlibConfig(Config):  # noqa: D101
 
         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)
@@ -102,6 +109,7 @@ class XlibDisplayConfig(DisplayConfig):  # noqa: D101
 
         self.glx_info = info
         self.fbconfig = fbconfig
+        self.transparent = False
 
         for name, attr in self.attribute_ids.items():
             value = c_int()
@@ -110,6 +118,22 @@ class XlibDisplayConfig(DisplayConfig):  # noqa: D101
             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
 

pyglet/graphics/vertexbuffer.py

@@ -1,6 +1,6 @@
 """OpenGL Buffer Objects.
 
-:py:class:`~BufferObject` and a :py:class:`~BackedBufferObject` are provied.
+:py:class:`~BufferObject` and a :py:class:`~BackedBufferObject` are provided.
 The first is a lightweight abstraction over an OpenGL buffer, as created
 with ``glGenBuffers``. The backed buffer object is similar, but provides a
 full mirror of the data in CPU memory. This allows for delayed uploading of

pyglet/gui/frame.py

@@ -24,7 +24,7 @@ class Frame:
 
         Args:
             window:
-                The SpatialHash will recieve events from this Window.
+                The SpatialHash will receive events from this Window.
                 Appropriate events will be passed on to all added Widgets.
             enable:
                 Whether to enable frame.
@@ -168,7 +168,7 @@ class MovableFrame(Frame):
 
         Args:
             window:
-                The SpatialHash will recieve events from this Window.
+                The SpatialHash will receive events from this Window.
                 Appropriate events will be passed on to all added Widgets.
             enable:
                 Whether to enable frame.

pyglet/gui/widgets.py

@@ -601,7 +601,7 @@ class TextEntry(WidgetBase):
             self._caret.on_text_motion_select(motion)
 
     def on_commit(self, widget: TextEntry, text: str) -> None:
-        """Event: dispatches the current text when commited via Enter/Return key."""
+        """Event: dispatches the current text when committed via Enter/Return key."""
 
 
 TextEntry.register_event_type('on_commit')

pyglet/image/__init__.py

@@ -556,7 +556,7 @@ class ImageData(AbstractImage):
         Note:
              Conversion to another format is done on the CPU, and can be
              somewhat costly for larger images. Consider performing conversion
-             at load time for framerate sensitive applictions.
+             at load time for framerate sensitive applications.
         """
         fmt = fmt or self._desired_format
         pitch = pitch or self._current_pitch
@@ -1201,7 +1201,7 @@ class Texture(AbstractImage):
                            layer: int = 0, access: int = GL_READ_WRITE, fmt: int = GL_RGBA32F):
         """Bind as an ImageTexture for use with a :py:class:`~pyglet.shader.ComputeShaderProgram`.
 
-        .. note:: OpenGL 4.3, or 4.2 with the GL_ARB_compute_shader extention is required.
+        .. note:: OpenGL 4.3, or 4.2 with the GL_ARB_compute_shader extension is required.
         """
         glBindImageTexture(unit, self.id, level, layered, layer, access, fmt)
 
@@ -1211,7 +1211,7 @@ class Texture(AbstractImage):
                fmt: int = GL_RGBA, blank_data: bool = True) -> Texture:
         """Create a Texture
 
-        Create a Texture with the specified dimentions, target and format.
+        Create a Texture with the specified dimensions, target and format.
         On return, the texture will be bound.
 
         Args:

pyglet/image/buffer.py

@@ -1,7 +1,7 @@
 """OpenGL Framebuffer abstractions.
 
 This module provides classes for working with Framebuffers & Renderbuffers
-and their attachments. Attachements can be pyglet Texture objects, which allows
+and their attachments. Attachments can be pyglet Texture objects, which allows
 easily accessing their data, saving to disk, etc. Renderbuffers can be used
 if you don't need to access their data at a later time. For example::
 
@@ -40,7 +40,7 @@ if TYPE_CHECKING:
 
 
 def get_max_color_attachments() -> int:
-    """Get the maximum allow Framebuffer Color attachements."""
+    """Get the maximum allow Framebuffer Color attachments."""
     number = GLint()
     glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, number)
     return number.value
@@ -144,7 +144,7 @@ class Framebuffer:
 
         Unbind should be called to prevent further rendering
         to the framebuffer, or if you wish to access data
-        from its Texture atachments.
+        from its Texture attachments.
         """
         glBindFramebuffer(self.target, 0)
 

pyglet/input/base.py

@@ -71,7 +71,7 @@ class Device:
         Args:
             window:
                 Optional window to associate with the device.  The behaviour
-                of this parameter is device and operating system dependant.
+                of this parameter is device and operating system dependent.
                 It can usually be omitted for most devices.
             exclusive:
                 If ``True`` the device will be opened exclusively so that no
@@ -103,7 +103,7 @@ class Device:
         string. This is generated from the hardware identifiers,
         and is in the same format as was popularized by SDL2.
         GUIDs differ between platforms, but are generally 32
-        hexidecimal characters.
+        hexadecimal characters.
         """
         raise NotImplementedError('abstract')
 
@@ -506,7 +506,7 @@ class Controller(EventDispatcher):
     """
 
     def __init__(self, device: Device, mapping: dict):
-        """Create a Controller instace mapped to a Device.
+        """Create a Controller instance mapped to a Device.
 
         .. versionadded:: 2.0
         """
@@ -575,7 +575,7 @@ class Controller(EventDispatcher):
             A string, currently one of "PS", "XB", or "GENERIC".
         """
         product_id = None
-        # TODO: add more checks for vender hardware ids.
+        # TODO: add more checks for vendor hardware ids.
 
         # Windows
         if self.name == 'XINPUTCONTROLLER':
@@ -672,7 +672,7 @@ class Controller(EventDispatcher):
     def _bind_dedicated_hat(self, relation: Relation, control: AbsoluteAxis) -> None:
         # 8-directional hat encoded as a single control (Windows/Mac)
         _vecs = (Vec2(0.0, 1.0), Vec2(1.0, 1.0), Vec2(1.0, 0.0), Vec2(1.0, -1.0),       # n, ne, e, se
-                  Vec2(0.0, -1.0), Vec2(-1.0, -1.0), Vec2(-1.0, 0.0), Vec2(-1.0, 1.0))   # s, sw, w, nw
+                 Vec2(0.0, -1.0), Vec2(-1.0, -1.0), Vec2(-1.0, 0.0), Vec2(-1.0, 1.0))   # s, sw, w, nw
         _input_map = {key: val for key, val in zip(range(int(control.min), int(control.max + 1)), _vecs)}
 
         # For some Directinput devices:
@@ -730,8 +730,8 @@ class Controller(EventDispatcher):
 
                         self._bind_axis_control(relation, control, dpname)
 
-            except IndexError:
-                warnings.warn(f"Could not map '{relation}' to '{name}'")
+            except (IndexError, AttributeError, KeyError):
+                warnings.warn(f"Could not map physical Control '{relation}' to '{name}'")
                 continue
 
     def open(self, window: None | BaseWindow = None, exclusive: bool = False) -> None:
@@ -1096,7 +1096,7 @@ class ControllerManager(EventDispatcher):
 
     def on_connect(self, controller) -> Controller:
         """A Controller has been connected. If this is
-        a previously dissconnected Controller that is
+        a previously disconnected Controller that is
         being re-connected, the same Controller instance
         will be returned.
         """

pyglet/input/linux/evdev.py

@@ -471,7 +471,7 @@ class EvdevControllerManager(ControllerManager, XlibSelectDevice):
         if controller := self._controllers.get(name, _create_controller(device)):
             self._controllers[name] = controller
             # Dispatch event in main thread:
-            pyglet.app.platform_event_loop.post_event(self, 'on_connect', controller)
+            self.post_event('on_connect', controller)
 
     def select(self):
         """Triggered whenever the devices_file changes."""

pyglet/libs/darwin/cocoapy/cocoalibs.py

@@ -232,6 +232,8 @@ NSDeviceSize = c_void_p.in_dll(appkit, 'NSDeviceSize')
 NSDeviceResolution = c_void_p.in_dll(appkit, 'NSDeviceResolution')
 NSDragOperationGeneric = 4
 
+NSStatusWindowLevel = 25
+
 
 # /System/Library/Frameworks/AppKit.framework/Headers/NSEvent.h
 NSAnyEventMask = 0xFFFFFFFF     # NSUIntegerMax
@@ -336,7 +338,7 @@ NSOpenGLProfileVersion3_2Core = 0x3200    # choose an OpenGL 3.2 Core Implementa
 NSOpenGLProfileVersion4_1Core = 0x4100    # choose an OpenGL 4.1 Core Implementation
 
 NSOpenGLCPSwapInterval        = 222
-
+NSOpenGLCPSurfaceOpacity      = 236
 
 # /System/Library/Frameworks/ApplicationServices.framework/Frameworks/...
 #     CoreGraphics.framework/Headers/CGImage.h

pyglet/libs/win32/__init__.py

@@ -114,6 +114,8 @@ _user32.DestroyWindow.restype = BOOL
 _user32.DestroyWindow.argtypes = [HWND]
 _user32.DispatchMessageW.restype = LRESULT
 _user32.DispatchMessageW.argtypes = [LPMSG]
+_user32.EnumDisplayDevicesW.restype = BOOL
+_user32.EnumDisplayDevicesW.argtypes = [LPCWSTR, DWORD, POINTER(DISPLAY_DEVICEW), DWORD]
 _user32.EnumDisplayMonitors.restype = BOOL
 _user32.EnumDisplayMonitors.argtypes = [HDC, LPRECT, MONITORENUMPROC, LPARAM]
 _user32.EnumDisplaySettingsW.restype = BOOL
@@ -131,6 +133,8 @@ _user32.GetDesktopWindow.restype = HWND
 _user32.GetDesktopWindow.argtypes = []
 _user32.GetKeyState.restype = c_short
 _user32.GetKeyState.argtypes = [c_int]
+_user32.GetLayeredWindowAttributes.restype = BOOL
+_user32.GetLayeredWindowAttributes.argtypes = [HWND, POINTER(COLORREF), POINTER(BYTE), POINTER(DWORD)]
 _user32.GetMessageW.restype = BOOL
 _user32.GetMessageW.argtypes = [LPMSG, HWND, UINT, UINT]
 _user32.GetMonitorInfoW.restype = BOOL
@@ -139,6 +143,8 @@ _user32.GetQueueStatus.restype = DWORD
 _user32.GetQueueStatus.argtypes = [UINT]
 _user32.GetSystemMetrics.restype = c_int
 _user32.GetSystemMetrics.argtypes = [c_int]
+_user32.GetWindowLongW.restype = LONG
+_user32.GetWindowLongW.argtypes = [HWND, c_int]
 _user32.LoadCursorW.restype = HCURSOR
 _user32.LoadCursorW.argtypes = [HINSTANCE, c_wchar_p]
 _user32.LoadIconW.restype = HICON
@@ -183,6 +189,8 @@ _user32.SetFocus.restype = HWND
 _user32.SetFocus.argtypes = [HWND]
 _user32.SetForegroundWindow.restype = BOOL
 _user32.SetForegroundWindow.argtypes = [HWND]
+_user32.SetLayeredWindowAttributes.restype = BOOL
+_user32.SetLayeredWindowAttributes.argtypes = [HWND, COLORREF, BYTE, DWORD]
 _user32.SetTimer.restype = UINT_PTR
 _user32.SetTimer.argtypes = [HWND, UINT_PTR, UINT, TIMERPROC]
 _user32.KillTimer.restype = UINT_PTR
@@ -249,6 +257,10 @@ _dwmapi.DwmIsCompositionEnabled.restype = c_int
 _dwmapi.DwmIsCompositionEnabled.argtypes = [POINTER(INT)]
 _dwmapi.DwmFlush.restype = c_int
 _dwmapi.DwmFlush.argtypes = []
+_dwmapi.DwmGetColorizationColor.restype = HRESULT
+_dwmapi.DwmGetColorizationColor.argtypes = [POINTER(DWORD), POINTER(BOOL)]
+_dwmapi.DwmEnableBlurBehindWindow.restype = HRESULT
+_dwmapi.DwmEnableBlurBehindWindow.argtypes = [HWND, POINTER(DWM_BLURBEHIND)]
 
 # _shell32
 _shell32.DragAcceptFiles.restype = c_void

pyglet/libs/win32/constants.py

@@ -5083,3 +5083,7 @@ DEVICE_NOTIFY_WINDOW_HANDLE = 0
 DEVICE_NOTIFY_SERVICE_HANDLE = 1
 
 USER_DEFAULT_SCREEN_DPI = 96
+
+QDC_ONLY_ACTIVE_PATHS = 0x00000002
+DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 0x00000001
+DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 0x00000002

pyglet/libs/win32/types.py

@@ -676,3 +676,100 @@ class DEV_BROADCAST_DEVICEINTERFACE(Structure):
         ('dbcc_classguid', com.GUID),
         ('dbcc_name', ctypes.c_wchar * 256)
     )
+
+
+class DISPLAY_DEVICEW(ctypes.Structure):
+    _fields_ = [
+        ('cb', DWORD),
+        ('DeviceName', WCHAR * 32),
+        ('DeviceString', WCHAR * 128),
+        ('StateFlags', DWORD),
+        ('DeviceID', WCHAR * 128),
+        ('DeviceKey', WCHAR * 128),
+    ]
+
+
+# Structures below are to retrieve a monitor name...
+class LUID(ctypes.Structure):
+    _fields_ = [('LowPart', DWORD), ('HighPart', LONG)]
+
+
+class _SourceInfoStruct(ctypes.Structure):
+    _fields_ = [('cloneGroupId', UINT32, 16), ('sourceModeInfoIdx', UINT32, 16)]
+
+
+class _DisplayUnion(ctypes.Union):
+    _fields_ = [('modeInfoIdx', UINT32), ('DUMMYSTRUCTNAME', _SourceInfoStruct)]
+
+
+class DISPLAYCONFIG_PATH_SOURCE_INFO(ctypes.Structure):
+    _fields_ = [('adapterId', LUID), ('id', UINT32), ('DUMMYUNIONNAME', _DisplayUnion), ('statusFlags', UINT32)]
+
+
+class _DummyStructTarget(ctypes.Structure):
+    _fields_ = [
+        ('desktopModeInfoIdx', UINT32, 16),
+        ('targetModeInfoIdx', UINT32, 16),
+    ]
+
+
+class _DummyUnionTarget(ctypes.Union):
+    _fields_ = [('modeInfoIdx', UINT32), ('DUMMYSTRUCTNAME', _DummyStructTarget)]
+
+
+class DISPLAYCONFIG_RATIONAL(ctypes.Structure):
+    _fields_ = [('Numerator', UINT32), ('Denominator', UINT32)]
+
+    def __repr__(self):
+        return f"DISPLAYCONFIG_RATIONAL(num={self.Numerator}, denom={self.Denominator})"
+
+
+class DISPLAYCONFIG_PATH_TARGET_INFO(ctypes.Structure):
+    _fields_ = [
+        ('adapterId', LUID),
+        ('id', UINT32),
+        ('DUMMYUNIONNAME', _DummyUnionTarget),
+        ('outputTechnology', UINT32),
+        ('rotation', UINT32),
+        ('scaling', UINT32),
+        ('refreshRate', DISPLAYCONFIG_RATIONAL),
+        ('scanLineOrdering', UINT32),
+        ('targetAvailable', BOOL),
+        ('statusFlags', UINT32),
+    ]
+
+
+class DISPLAYCONFIG_PATH_INFO(ctypes.Structure):
+    _fields_ = [
+        ('sourceInfo', DISPLAYCONFIG_PATH_SOURCE_INFO),
+        ('targetInfo', DISPLAYCONFIG_PATH_TARGET_INFO),
+        ('flags', UINT32),
+    ]
+
+
+class DISPLAYCONFIG_DEVICE_INFO_HEADER(ctypes.Structure):
+    _fields_ = [('type', UINT32),
+                ('size', UINT32),
+                ('adapterId', LUID),
+                ('id', UINT32)
+                ]
+
+
+class DISPLAYCONFIG_SOURCE_DEVICE_NAME(ctypes.Structure):
+    _fields_ = [
+        ('header', DISPLAYCONFIG_DEVICE_INFO_HEADER),
+        ('viewGdiDeviceName', WCHAR * 32)
+    ]
+
+
+class DISPLAYCONFIG_TARGET_DEVICE_NAME(ctypes.Structure):
+    _fields_ = [
+        ('header', DISPLAYCONFIG_DEVICE_INFO_HEADER),
+        ('flags', UINT32),
+        ('outputTechnology', UINT32),
+        ('edidManufactureId', UINT16),
+        ('edidProductCodeId', UINT16),
+        ('connectorInstance', UINT32),
+        ('monitorFriendlyDeviceName', WCHAR * 64),
+        ('monitorDevicePath', WCHAR * 128),
+    ]

pyglet/libs/x11/xrandr.py

@@ -0,0 +1,166 @@
+import warnings
+from ctypes import c_ulong, c_int, POINTER, Structure, c_char_p, c_uint, c_ushort
+
+import pyglet
+from pyglet.libs.x11.xlib import (
+    Time,
+    Window,
+    Display,
+    XCloseDisplay,
+    XDefaultRootWindow,
+    XOpenDisplay,
+)
+
+lib = None
+try:
+    lib = pyglet.lib.load_library("Xrandr")
+except ImportError:
+    if pyglet.options.debug_lib:
+        warnings.warn("Xrandr could not be loaded.")
+    raise ImportError
+
+RRCrtc      = c_ulong        # typedef XID
+RROutput    = c_ulong        # typedef XID
+RRMode      = c_ulong        # typedef XID
+Connection  = c_ushort       # Connection in Xrandr.h
+SubpixelOrder = c_ushort     # SubpixelOrder in Xrandr.h
+XRRModeFlags = c_ulong
+
+class XRRModeInfo(Structure):
+    _fields_ = [
+        ("id",          RRMode),     # mode ID
+        ("width",       c_uint),   # horizontal resolution
+        ("height",      c_uint),   # vertical resolution
+        ("dotClock",    c_ulong),    # pixel clock (in Hz)
+        ("hSyncStart",  c_uint),
+        ("hSyncEnd",    c_uint),
+        ("hTotal",      c_uint),
+        ("hSkew",       c_uint),
+        ("vSyncStart",  c_uint),
+        ("vSyncEnd",    c_uint),
+        ("vTotal",      c_uint),
+        ("name",        c_char_p),
+        ("nameLength",  c_uint),
+        ("modeFlags",   XRRModeFlags),
+    ]
+
+
+class XRRScreenResources(Structure):
+    _fields_ = [
+        ("timestamp",        Time),
+        ("configTimestamp",  Time),
+        ("ncrtc",            c_int),
+        ("crtcs",            POINTER(RRCrtc)),
+        ("noutput",          c_int),
+        ("outputs",          POINTER(RROutput)),
+        ("nmode",            c_int),
+        ("modes",            POINTER(XRRModeInfo)),
+    ]
+
+
+class XRROutputInfo(Structure):
+    _fields_ = [
+        ("timestamp",      Time),
+        ("crtc",           RRCrtc),
+        ("name",           c_char_p),
+        ("nameLen",        c_int),
+        ("mm_width",       c_ulong),
+        ("mm_height",      c_ulong),
+        ("connection",     Connection),
+        ("subpixel_order", SubpixelOrder),
+        ("ncrtc",          c_int),
+        ("crtcs",          POINTER(RRCrtc)),
+        ("nclone",         c_int),
+        ("clones",         POINTER(RROutput)),
+        ("nmode",          c_int),
+        ("npreferred",     c_int),
+        ("modes",          POINTER(RRMode)),
+    ]
+
+class XRRCrtcInfo(Structure):
+    _fields_ = [
+        ("timestamp",  Time),
+        ("x",          c_int),
+        ("y",          c_int),
+        ("width",      c_uint),
+        ("height",     c_uint),
+        ("mode",       RRMode),
+        ("rotation",   c_int),
+        ("noutput",    c_int),
+        ("outputs",    POINTER(RROutput)),
+        ("rotations",  c_ushort),
+        ("npossible",  c_int),
+        ("possible",   POINTER(RROutput)),
+    ]
+
+
+if lib:
+    XRRQueryVersion = lib.XRRQueryVersion
+    XRRQueryVersion.argtypes = [POINTER(Display), POINTER(c_int), POINTER(c_int)]
+    XRRQueryVersion.restype    = c_int
+
+    XRRGetScreenResources = lib.XRRGetScreenResources
+    XRRGetScreenResources.argtypes = [POINTER(Display), Window]
+    XRRGetScreenResources.restype = POINTER(XRRScreenResources)
+
+    XRRGetOutputPrimary = lib.XRRGetOutputPrimary
+    XRRGetOutputPrimary.argtypes = [POINTER(Display), Window]
+    XRRGetOutputPrimary.restype = RROutput
+
+    XRRGetScreenResourcesCurrent = lib.XRRGetScreenResourcesCurrent
+    XRRGetScreenResourcesCurrent.argtypes = [POINTER(Display), Window]
+    XRRGetScreenResourcesCurrent.restype = POINTER(XRRScreenResources)
+
+    XRRFreeScreenResources = lib.XRRFreeScreenResources
+    XRRFreeScreenResources.argtypes = [POINTER(XRRScreenResources)]
+    XRRFreeScreenResources.restype = None
+
+    XRRGetOutputInfo = lib.XRRGetOutputInfo
+    XRRGetOutputInfo.argtypes = [POINTER(Display), POINTER(XRRScreenResources), RROutput]
+    XRRGetOutputInfo.restype  = POINTER(XRROutputInfo)
+
+    XRRFreeOutputInfo = lib.XRRFreeOutputInfo
+    XRRFreeOutputInfo.argtypes = [POINTER(XRROutputInfo)]
+    XRRFreeOutputInfo.restype = None
+
+    XRRGetCrtcInfo = lib.XRRGetCrtcInfo
+    XRRGetCrtcInfo.argtypes = [POINTER(Display), POINTER(XRRScreenResources), RRCrtc]
+    XRRGetCrtcInfo.restype = POINTER(XRRCrtcInfo)
+
+    XRRSetCrtcConfig = lib.XRRSetCrtcConfig
+    XRRSetCrtcConfig.argtypes = argtypes = [POINTER(Display), POINTER(XRRScreenResources), RRCrtc, Time, c_int, c_int, RRMode, c_int,  POINTER(RROutput), c_int]
+    XRRSetCrtcConfig.restype = c_int
+
+    XRRFreeCrtcInfo = lib.XRRFreeCrtcInfo
+    XRRFreeCrtcInfo.argtypes = [POINTER(XRRCrtcInfo)]
+    XRRFreeCrtcInfo.restype    = None
+
+def list_connected_outputs():
+    dpy = XOpenDisplay(None)
+    if not dpy:
+        raise RuntimeError("Cannot open DISPLAY")
+
+    root = XDefaultRootWindow(dpy)
+    res_p = XRRGetScreenResources(dpy, root)
+    if not res_p:
+        XCloseDisplay(dpy)
+        raise RuntimeError("Failed to get screen resources")
+
+    res = res_p.contents
+    outputs = []
+    for i in range(res.noutput):
+        out_id = res.outputs[i]
+        info_p = XRRGetOutputInfo(dpy, res_p, out_id)
+        if info_p:
+            info = info_p.contents
+            if info.connection == 0:  # Connected.
+                outputs.append(info.name.decode())
+            XRRFreeOutputInfo(info_p)
+
+    XRRFreeScreenResources(res_p)
+    XCloseDisplay(dpy)
+    return outputs
+
+if __name__ == "__main__":
+    for name in list_connected_outputs():
+        print(name)

pyglet/libs/x11/xrender.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import warnings
+from ctypes import Structure, c_ushort, c_ulong, c_int, c_void_p, POINTER
+import pyglet.lib
+from pyglet.libs.x11.xlib import Visual
+
+lib = None
+try:
+    lib = pyglet.lib.load_library("Xrender")
+except ImportError:
+    if pyglet.options.debug_lib:
+        warnings.warn("XRender could not be loaded.")
+
+
+class XRenderDirectFormat(Structure):
+    _fields_ = [
+        ('red', c_ushort),
+        ('redMask', c_ushort),
+        ('green', c_ushort),
+        ('greenMask', c_ushort),
+        ('blue', c_ushort),
+        ('blueMask', c_ushort),
+        ('alpha', c_ushort),
+        ('alphaMask', c_ushort),
+    ]
+
+class XRenderPictFormat(Structure):
+    _fields_ = [
+        ('id', c_ulong),
+        ('type', c_int),
+        ('depth', c_int),
+        ('direct', XRenderDirectFormat),
+        ('colormap', c_ulong),
+    ]
+
+# XRenderFindVisualFormat(Display *dpy, Visual *visual)
+try:
+    XRenderFindVisualFormat = lib.XRenderFindVisualFormat
+    XRenderFindVisualFormat.argtypes = [c_void_p, POINTER(Visual)]
+    XRenderFindVisualFormat.restype = POINTER(XRenderPictFormat)
+except ValueError:
+    XRenderFindVisualFormat = None

pyglet/libs/x11/xsync.py

@@ -406,6 +406,49 @@ XSyncGetPriority = _lib.XSyncGetPriority
 XSyncGetPriority.restype = c_int
 XSyncGetPriority.argtypes = [POINTER(Display), XID, POINTER(c_int)]
 
+# Shape kind
+ShapeBounding = 0
+ShapeClip = 1
+ShapeInput = 2
+
+# Shape operation
+ShapeSet = 0
+ShapeUnion = 1
+ShapeIntersect = 2
+ShapeSubtract = 3
+ShapeInvert = 4
+
+XShapeCombineRegion = _lib.XShapeCombineRegion
+XShapeCombineRegion.argtypes = [
+    POINTER(Display),
+    c_void_p,
+    ctypes.c_int,  # shape kind
+    ctypes.c_int, ctypes.c_int,  # x, y offset
+    c_void_p,
+    ctypes.c_int   # ShapeOp
+]
+
+XShapeCombineMask = _lib.XShapeCombineMask
+XShapeCombineMask.argtypes = [
+    Display,       # *display
+    c_void_p,        # dest window
+    ctypes.c_int,  # shape_kind (e.g., ShapeInput)
+    ctypes.c_int,  # x offset
+    ctypes.c_int,  # y offset
+    ctypes.c_ulong,  # Pixmap (can be 0 for None)
+    ctypes.c_int   # ShapeOp (e.g., ShapeSet)
+]
+XShapeCombineMask.restype = None
+
+XShapeQueryExtension = _lib.XShapeQueryExtension
+XShapeQueryExtension.argtypes = [Display, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)]
+XShapeQueryExtension.restype = Bool
+
+def has_shape_support(display: Display) -> bool:
+    event_base = ctypes.c_int()
+    error_base = ctypes.c_int()
+    return XShapeQueryExtension(display, ctypes.byref(event_base), ctypes.byref(error_base))
+
 
 __all__ = ['SYNC_MAJOR_VERSION', 'SYNC_MINOR_VERSION', 'X_SyncInitialize',
 'X_SyncListSystemCounters', 'X_SyncCreateCounter', 'X_SyncSetCounter',