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

pyglet/display/xlib.py

@@ -1,25 +1,21 @@
 from __future__ import annotations
 
 import ctypes
-from ctypes import c_int, c_char_p, c_buffer, POINTER, byref, cast
-
-from pyglet.util import asbytes
+import warnings
+from ctypes import POINTER, byref, c_buffer, c_char_p, c_int, cast
+from typing import TYPE_CHECKING
 
+import pyglet
 from pyglet import app
 from pyglet.app.xlib import XlibSelectDevice
+from pyglet.libs.x11 import xlib
+from pyglet.util import asbytes
 
-from ..libs.x11.xlib import Window
 from . import xlib_vidmoderestore
 from .base import Canvas, Display, Screen, ScreenMode
 
-
-# XXX
-# from pyglet.window import NoSuchDisplayException
-class NoSuchDisplayException(Exception):
-    pass
-
-
-from pyglet.libs.x11 import xlib
+if TYPE_CHECKING:
+    from pyglet.gl import Config
 
 try:
     from pyglet.libs.x11 import xinerama
@@ -42,6 +38,17 @@ try:
 except:
     _have_xf86vmode = False
 
+try:
+    from pyglet.libs.x11 import xrandr
+
+    _have_xrandr = True
+except ImportError:
+    _have_xrandr = False
+
+
+class NoSuchDisplayException(Exception):
+    pass
+
 
 # Set up error handler
 def _error_handler(display, event):
@@ -52,7 +59,6 @@ def _error_handler(display, event):
     # driver bugs (and so the reports are useless).  Nevertheless, set
     # environment variable PYGLET_DEBUG_X11 to 1 to get dumps of the error
     # and a traceback (execution will continue).
-    import pyglet
     if pyglet.options['debug_x11']:
         event = event.contents
         buf = c_buffer(1024)
@@ -64,6 +70,7 @@ def _error_handler(display, event):
         print(' resource:', event.resourceid)
 
         import traceback
+
         print('Python stack trace (innermost last):')
         traceback.print_stack()
     return 0
@@ -79,9 +86,11 @@ class XlibDisplay(XlibSelectDevice, Display):
     _x_im = None  # X input method
     # TODO close _x_im when display connection closed.
     _enable_xsync = False
-    _screens = None  # Cache of get_screens()
+    _screens: list[XlibScreen | XlibScreenXrandr | XlibScreenXinerama]
 
     def __init__(self, name=None, x_screen=None):
+        self._screens = []
+
         if x_screen is None:
             x_screen = 0
 
@@ -107,54 +116,95 @@ class XlibDisplay(XlibSelectDevice, Display):
         if _have_xsync:
             event_base = c_int()
             error_base = c_int()
-            if xsync.XSyncQueryExtension(self._display,
-                                         byref(event_base),
-                                         byref(error_base)):
+            if xsync.XSyncQueryExtension(self._display, byref(event_base), byref(error_base)):
                 major_version = c_int()
                 minor_version = c_int()
-                if xsync.XSyncInitialize(self._display,
-                                         byref(major_version),
-                                         byref(minor_version)):
+                if xsync.XSyncInitialize(self._display, byref(major_version), byref(minor_version)):
                     self._enable_xsync = True
 
         # Add to event loop select list.  Assume we never go away.
         app.platform_event_loop.select_devices.add(self)
 
-    def get_screens(self):
-        if self._screens:
-            return self._screens
-
-        if _have_xinerama and xinerama.XineramaIsActive(self._display):
+    def get_default_screen(self) -> Screen:
+        screens = self.get_screens()
+        if _have_xrandr:
+            for screen in screens:
+                if screen.is_primary:
+                    return screen
+
+        # Couldn't find a default screen, use the first in the list.
+        return self._screens[0]
+
+    def get_screens(self) -> list[XlibScreen]:
+        self._screens = []
+
+        # Use XRandr if available, as it appears more maintained and widely supported.
+        if _have_xrandr:
+            root = xlib.XDefaultRootWindow(self._display)
+
+            res_ptr = xrandr.XRRGetScreenResources(self._display, root)
+            if res_ptr:
+                primary = xrandr.XRRGetOutputPrimary(self._display, root)
+
+                res = res_ptr.contents
+                for i in range(res.noutput):
+                    output_id = res.outputs[i]
+                    output_info_ptr = xrandr.XRRGetOutputInfo(self._display, res_ptr, output_id)
+                    if not output_info_ptr:
+                        xrandr.XRRFreeOutputInfo(output_info_ptr)
+                        continue
+
+                    output_info: xrandr.XRROutputInfo = output_info_ptr.contents
+
+                    crtc_info_ptr = xrandr.XRRGetCrtcInfo(self._display, res_ptr, output_info.crtc)
+                    if not crtc_info_ptr:
+                        xrandr.XRRFreeCrtcInfo(crtc_info_ptr)
+                        continue
+
+                    crtc_info: xrandr.XRRCrtcInfo = crtc_info_ptr.contents
+
+                    self._screens.append(
+                        XlibScreenXrandr(
+                            self,
+                            crtc_info.x,
+                            crtc_info.y,
+                            crtc_info.width,
+                            crtc_info.height,
+                            output_info.crtc,
+                            output_id,
+                            ctypes.string_at(output_info.name, output_info.nameLen).decode(),
+                            output_id == primary,
+                        ),
+                    )
+                    xrandr.XRRFreeCrtcInfo(crtc_info_ptr)
+                    xrandr.XRRFreeOutputInfo(output_info_ptr)
+
+            xrandr.XRRFreeScreenResources(res_ptr)
+
+        if not self._screens and _have_xinerama and xinerama.XineramaIsActive(self._display):
             number = c_int()
             infos = xinerama.XineramaQueryScreens(self._display, byref(number))
             infos = cast(infos, POINTER(xinerama.XineramaScreenInfo * number.value)).contents
-            self._screens = []
+
             using_xinerama = number.value > 1
-            for info in infos:
-                self._screens.append(XlibScreen(self,
-                                                info.x_org,
-                                                info.y_org,
-                                                info.width,
-                                                info.height,
-                                                using_xinerama))
+            for idx, info in enumerate(infos):
+                self._screens.append(
+                    XlibScreenXinerama(self, info.x_org, info.y_org, info.width, info.height, using_xinerama, idx),
+                )
             xlib.XFree(infos)
-        else:
+        elif not self._screens:
             # No xinerama
             screen_info = xlib.XScreenOfDisplay(self._display, self.x_screen)
-            screen = XlibScreen(self,
-                                0, 0,
-                                screen_info.contents.width,
-                                screen_info.contents.height,
-                                False)
+            screen = XlibScreen(self, 0, 0, screen_info.contents.width, screen_info.contents.height)
             self._screens = [screen]
         return self._screens
 
     # XlibSelectDevice interface
 
-    def fileno(self):
+    def fileno(self) -> int:
         return self._fileno
 
-    def select(self):
+    def select(self) -> None:
         e = xlib.XEvent()
         while xlib.XPending(self._display):
             xlib.XNextEvent(self._display, e)
@@ -171,18 +221,17 @@ class XlibDisplay(XlibSelectDevice, Display):
 
             dispatch(e)
 
-    def poll(self):
+    def poll(self) -> int:
         return xlib.XPending(self._display)
 
 
 class XlibScreen(Screen):
     _initial_mode = None
 
-    def __init__(self, display, x, y, width, height, xinerama):
+    def __init__(self, display: XlibDisplay, x: int, y: int, width: int, height: int):
         super().__init__(display, x, y, width, height)
-        self._xinerama = xinerama
 
-    def get_dpi(self):
+    def get_dpi(self) -> int:
         resource = xlib.XResourceManagerString(self.display._display)
         dpi = 96
         if resource:
@@ -192,8 +241,7 @@ class XlibScreen(Screen):
             if db:
                 rs_type = c_char_p()
                 value = xlib.XrmValue()
-                if xlib.XrmGetResource(db, asbytes("Xft.dpi"), asbytes("Xft.dpi"),
-                                            byref(rs_type), byref(value)):
+                if xlib.XrmGetResource(db, asbytes("Xft.dpi"), asbytes("Xft.dpi"), byref(rs_type), byref(value)):
                     if value.addr and rs_type.value == b'String':
                         dpi = int(value.addr)
 
@@ -201,10 +249,10 @@ class XlibScreen(Screen):
 
         return dpi
 
-    def get_scale(self):
+    def get_scale(self) -> float:
         return self.get_dpi() / 96
 
-    def get_matching_configs(self, template):
+    def get_matching_configs(self, template: Config):
         canvas = XlibCanvas(self.display, None)
         configs = template.match(canvas)
         # XXX deprecate
@@ -212,41 +260,40 @@ class XlibScreen(Screen):
             config.screen = self
         return configs
 
-    def get_modes(self):
+    def get_modes(self) -> list[XlibScreenModeXF86]:
         if not _have_xf86vmode:
             return []
 
-        if self._xinerama:
-            # If Xinerama/TwinView is enabled, xf86vidmode's modelines
-            # correspond to metamodes, which don't distinguish one screen from
-            # another.  XRandR (broken) or NV (complicated) extensions needed.
-            return []
-
         count = ctypes.c_int()
         info_array = ctypes.POINTER(ctypes.POINTER(xf86vmode.XF86VidModeModeInfo))()
         xf86vmode.XF86VidModeGetAllModeLines(self.display._display, self.display.x_screen, count, info_array)
 
+        depth = xlib.XDefaultDepth(self.display._display, self.display.x_screen)
+
         # Copy modes out of list and free list
         modes = []
         for i in range(count.value):
             info = xf86vmode.XF86VidModeModeInfo()
-            ctypes.memmove(ctypes.byref(info),
-                           ctypes.byref(info_array.contents[i]),
-                           ctypes.sizeof(info))
-            modes.append(XlibScreenMode(self, info))
+            ctypes.memmove(
+                ctypes.byref(info),
+                ctypes.byref(info_array.contents[i]),
+                ctypes.sizeof(info),
+            )
+
+            modes.append(XlibScreenModeXF86(self, info, depth))
             if info.privsize:
                 xlib.XFree(info.private)
         xlib.XFree(info_array)
 
         return modes
 
-    def get_mode(self):
+    def get_mode(self) -> XlibScreenMode:
         modes = self.get_modes()
         if modes:
             return modes[0]
         return None
 
-    def set_mode(self, mode):
+    def set_mode(self, mode: XlibScreenModeXF86):
         assert mode.screen is self
 
         if not self._initial_mode:
@@ -265,24 +312,192 @@ class XlibScreen(Screen):
         if self._initial_mode:
             self.set_mode(self._initial_mode)
 
+    def get_display_id(self) -> int:
+        # No real unique ID is available, just hash together the properties.
+        return hash((self.x, self.y, self.width, self.height))
+
+    def get_monitor_name(self) -> str:
+        # No way to get any screen name without XRandr or EDID information.
+        return "Unknown"
+
     def __repr__(self):
-        return f"{self.__class__.__name__}(display={self.display!r}, x={self.x}, y={self.y}, " \
-               f"width={self.width}, height={self.height}, xinerama={self._xinerama})"
+        return (
+            f"{self.__class__.__name__}(display={self.display!r}, x={self.x}, y={self.y}, "
+            f"width={self.width}, height={self.height})"
+        )
+
+
+class XlibScreenXinerama(XlibScreen):
+    def __init__(self, display: XlibDisplay, x: int, y: int, width: int, height: int, using_xinerama: bool, idx: int) -> None:
+        super().__init__(display, x, y, width, height)
+        self._xinerama = using_xinerama
+        self.idx = idx
+
+    def get_display_id(self) -> int:
+        # No real unique ID is available, just hash together the properties.
+        return hash((self.idx, self.x, self.y, self.width, self.height))
+
+    def get_modes(self):
+        if self._xinerama:
+            # If Xinerama/TwinView is enabled, xf86vidmode's modelines
+            # correspond to metamodes, which don't distinguish one screen from
+            # another.  XRandR (broken) or NV (complicated) extensions needed.
+            return []
+
+        return super().get_modes()
+
+
+class XlibScreenXrandr(XlibScreen):
+    def __init__(
+        self,
+        display: XlibDisplay,
+        x: int,
+        y: int,
+        width: int,
+        height: int,
+        crtc_id: int,
+        output_id: int,
+        name: str,
+        is_primary: bool,
+    ):
+        super().__init__(display, x, y, width, height)
+        self.crtc_id = crtc_id
+        self.output_id = output_id
+        self.name = name
+        self._is_primary = is_primary
+
+    @property
+    def is_primary(self):
+        return self._is_primary
+
+    @staticmethod
+    def _get_mode_info(resource: xrandr.XRRScreenResources, rrmode_id: int) -> xrandr.XRRModeInfo | None:
+        for i in range(resource.nmode):
+            if resource.modes[i].id == rrmode_id:
+                return resource.modes[i]
+
+        return None
+
+    def set_mode(self, mode: XlibScreenModeXrandr) -> None:
+        assert mode.screen is self
+
+        if not self._initial_mode:
+            self._initial_mode = self.get_mode()
+
+        root = xlib.XDefaultRootWindow(self.display._display)
+        res_ptr = xrandr.XRRGetScreenResourcesCurrent(self.display._display, root)
+        if res_ptr:
+            crtc_info_ptr = xrandr.XRRGetCrtcInfo(self.display._display, res_ptr, self.crtc_id)
+            if crtc_info_ptr:
+                crtc_info = crtc_info_ptr.contents
+                status = xrandr.XRRSetCrtcConfig(
+                    self.display._display,
+                    res_ptr,
+                    self.crtc_id,
+                    xlib.CurrentTime,
+                    crtc_info.x,
+                    crtc_info.y,
+                    mode.mode_id,
+                    crtc_info.rotation,
+                    crtc_info.outputs,
+                    crtc_info.noutput,
+                )
+                if status != 0 and pyglet.options['debug_x11']:
+                    warnings.warn(f"Could not set screen mode: {status}")
+                xlib.XFlush(self.display._display)
+
+                self.width = mode.width
+                self.height = mode.height
+
+            xrandr.XRRFreeCrtcInfo(crtc_info_ptr)
+        xrandr.XRRFreeScreenResources(res_ptr)
+
+    def get_modes(self) -> list[XlibScreenModeXrandr]:
+        modes = []
+        root = xlib.XDefaultRootWindow(self.display._display)
+        res_ptr = xrandr.XRRGetScreenResourcesCurrent(self.display._display, root)
+        output_info_ptr = xrandr.XRRGetOutputInfo(self.display._display, res_ptr, self.output_id)
+
+        res = res_ptr.contents
+        output_info = output_info_ptr.contents
+
+        depth = xlib.XDefaultDepth(self.display._display, self.display.x_screen)
+
+        for i in range(output_info_ptr.contents.nmode):
+            mode_id = output_info.modes[i]
+            xrandr_mode = self._get_mode_info(res, mode_id)
+            if xrandr_mode:
+                mode = XlibScreenModeXrandr(self, xrandr_mode, mode_id, depth)
+                modes.append(mode)
+
+        xrandr.XRRFreeOutputInfo(output_info_ptr)
+        xrandr.XRRFreeScreenResources(res_ptr)
+        return modes
+
+    def get_mode(self) -> XlibScreenModeXrandr | None:
+        # Return the current mode.
+        root = xlib.XDefaultRootWindow(self.display._display)
+        res_ptr = xrandr.XRRGetScreenResourcesCurrent(self.display._display, root)
+        crtc_info_ptr = xrandr.XRRGetCrtcInfo(self.display._display, res_ptr, self.crtc_id)
+
+        crtc_info = crtc_info_ptr.contents
+        found_mode = None
+
+        for mode in self.get_modes():
+            if crtc_info.mode == mode.mode_id:
+                found_mode = mode
+                break
+
+        xrandr.XRRFreeCrtcInfo(crtc_info_ptr)
+        xrandr.XRRFreeScreenResources(res_ptr)
+        return found_mode
+
+    def get_display_id(self) -> int:
+        return self.output_id
+
+    def get_monitor_name(self) -> str:
+        return self.name
 
 
 class XlibScreenMode(ScreenMode):
-    def __init__(self, screen, info):
+    def __init__(self, screen: XlibScreen, width: int, height: int, rate: int, depth: int):
         super().__init__(screen)
+        self.width = width
+        self.height = height
+        self.rate = rate
+        self.depth = depth
+
+
+class XlibScreenModeXF86(XlibScreenMode):
+    def __init__(self, screen: XlibScreen, info: xf86vmode.XF86VidModeModeInfo, depth: int) -> None:
         self.info = info
-        self.width = info.hdisplay
-        self.height = info.vdisplay
-        self.rate = (info.dotclock * 1000) / (info.htotal * info.vtotal)
-        self.depth = None
+        width = info.hdisplay
+        height = info.vdisplay
+        rate = round((info.dotclock * 1000) / (info.htotal * info.vtotal))
+        super().__init__(screen, width, height, rate, depth)
+
+    def __repr__(self) -> str:
+        return f'XlibScreenMode(width={self.width!r}, height={self.height!r}, depth={self.depth!r}, rate={self.rate})'
+
+
+class XlibScreenModeXrandr(XlibScreenMode):
+    def __init__(self, screen: XlibScreen, mode_info: xrandr.XRRModeInfo, mode_id: int, depth: int) -> None:
+        self.mode_id = mode_id
+        super().__init__(screen, mode_info.width, mode_info.height, self._calculate_refresh_rate(mode_info), depth)
+
+    @staticmethod
+    def _calculate_refresh_rate(mode_info: xrandr.XRRModeInfo) -> int:
+        if mode_info.hTotal > 0 and mode_info.vTotal > 0:
+            return round(mode_info.dotClock / (mode_info.hTotal * mode_info.vTotal))
+        return 0
+
+    def __repr__(self) -> str:
+        return f'XlibScreenMode(width={self.width!r}, height={self.height!r}, depth={self.depth!r}, rate={self.rate})'
 
 
 class XlibCanvas(Canvas):  # noqa: D101
     display: XlibDisplay
 
-    def __init__(self, display: XlibDisplay, x_window: Window) -> None:  # noqa: D107
+    def __init__(self, display: XlibDisplay, x_window: xlib.Window) -> None:  # noqa: D107
         super().__init__(display)
         self.x_window = x_window

pyglet/event.py

@@ -120,10 +120,13 @@ from __future__ import annotations
 
 import inspect
 import os.path
+
 from functools import partial
 from typing import TYPE_CHECKING, Literal, Union
 from weakref import WeakMethod
 
+import pyglet
+
 if TYPE_CHECKING:
     from typing import Any, Callable, Generator
 
@@ -328,7 +331,7 @@ class EventDispatcher:
         handlers down the stack will receive this event.
 
         This method has several possible return values. If any event
-        hander has returned ``EVENT_HANDLED``, then this method will
+        handler has returned ``EVENT_HANDLED``, then this method will
         also return ``EVENT_HANDLED``. If not, this method will return
         ``EVENT_UNHANDLED``. If there were no events registered to
         receive this event, ``False`` is returned.
@@ -381,6 +384,19 @@ class EventDispatcher:
 
         return False
 
+    def post_event(self, event_type: str, *args: Any) -> bool | None:
+        """Post an event to the main application thread.
+
+        Unlike the :py:meth:`~pyglet.event.EventDispatcher.dispatch_event`
+        method, this method does not dispatch events directly. Instead, it
+        hands off the dispatch call to the main application thread. This
+        ensures that any event handlers are also executed in the main thread.
+
+        This method aliases :py:meth:`~pyglet.app.PlatformEventLoop.post_event`,
+        which can be seen for more information on behavior.
+        """
+        pyglet.app.platform_event_loop.post_event(self, event_type, *args)
+
     def _raise_dispatch_exception(self, event_type: str, args: Any, handler: Callable, exception: Exception) -> None:
         # A common problem in applications is having the wrong number of
         # arguments in an event handler.  This is caught as a TypeError in

pyglet/experimental/README.md

@@ -2,5 +2,5 @@ Experimental modules
 ====================
 
 This package contains experimental modules, which are included here for
-wider testing and feedback. Anything contined within may be broken, refactored,
+wider testing and feedback. Anything contained within may be broken, refactored,
 or removed without notice.

pyglet/experimental/jobs.py

@@ -92,7 +92,7 @@ class JobExecutor:
 
         All JobExecutor workers are Daemon Threads, so it is not strictly
         necessary to call shutdown() at program termination. However, if
-        it is no longer needed, shutdown() can be called ot free up the
+        it is no longer needed, shutdown() can be called to free up the
         thread resources.
         """
         if not self._queue:

pyglet/experimental/multitexture_sprite.py

@@ -378,7 +378,7 @@ class MultiTextureSprite(pyglet.sprite.Sprite):
         if new_tex.id is not self._textures[key].id:
             # Need to make a shallow copy to allow the batch object
             # to correctly split this sprite from other sprite's groups.
-            # if not then you will be modifing all othe the other sprites
+            # if not then you will be modifying all the other sprites
             # textures dict object as well.
             self._textures = self._textures.copy()
             self._textures[key] = new_tex
@@ -467,7 +467,7 @@ class MultiTextureSprite(pyglet.sprite.Sprite):
                The Image or Animation to set
         """
         if name in self._animations:
-            # Need to stop all animations temporarly so we can swap the layer out
+            # Need to stop all animations temporarily so we can swap the layer out
             pyglet.clock.unschedule(self._animate)
             self._animations.pop(name)
 

pyglet/font/__init__.py

@@ -68,7 +68,7 @@ def add_user_font(font: UserDefinedFontBase) -> None:
         Exception: If font provided is not derived from :py:class:`~pyglet.font.user.UserDefinedFontBase`.
     """
     if not isinstance(font, UserDefinedFontBase):
-        msg = "Font is not must be created fromm the UserDefinedFontBase."
+        msg = "Font must be created from the UserDefinedFontBase."
         raise Exception(msg)
 
     # Locate or create font cache

pyglet/font/base.py

@@ -7,10 +7,9 @@ classes as a documented interface to the concrete classes.
 from __future__ import annotations
 
 import abc
-from dataclasses import dataclass
-
 import unicodedata
-from typing import BinaryIO, ClassVar
+from dataclasses import dataclass
+from typing import Any, BinaryIO, ClassVar
 
 from pyglet import image
 from pyglet.gl import GL_LINEAR, GL_RGBA, GL_TEXTURE_2D
@@ -63,7 +62,7 @@ def grapheme_break(left: str, left_cc: str, right: str, right_cc: str) -> bool:
         return False
 
     # GB9b: Do not break after Prepend characters
-    if left in _LOGICAL_ORDER_EXCEPTION:  # noqa: SIM103
+    if left in _LOGICAL_ORDER_EXCEPTION:
         return False
 
     # GB999: Default to break
@@ -259,7 +258,11 @@ class Font:
             ``GL_NEAREST`` to prevent aliasing with pixelated fonts.
     """
     #: :meta private:
-    glyphs: dict[str | int, Glyph]
+    glyphs: dict[str | int | tuple[Any, int], Glyph]
+    # Glyphs can be cached in various ways:
+    # str: if no text shaping
+    # int: glyph index, if no fallback behavior.
+    # tuple: with a unique font identifier and glyph index
 
     texture_width: int = 512
     texture_height: int = 512