pyglet 2.0.14__tar.gz → 2.1.dev1__tar.gz

{pyglet-2.0.14 → pyglet-2.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglet
-Version: 2.0.14
+Version: 2.1.dev1
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8

{pyglet-2.0.14 → pyglet-2.1.dev1}/pyglet/__init__.py

@@ -6,10 +6,10 @@ More information is available at http://www.pyglet.org
 import os
 import sys
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict
 
 #: The release version
-version = '2.0.14'
+version = '2.1.dev1'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -93,15 +93,6 @@ if getattr(sys, 'frozen', None):
 #:     this option overrides it (to either force vsync on or off).  If unset,
 #:     or set to None, the `pyglet.window.Window.vsync` property behaves
 #:     as documented.
-#: xsync
-#:     If set (the default), pyglet will attempt to synchronise the drawing of
-#:     double-buffered windows to the border updates of the X11 window
-#:     manager.  This improves the appearance of the window during resize
-#:     operations.  This option only affects double-buffered windows on
-#:     X11 servers supporting the Xsync extension with a window manager
-#:     that implements the _NET_WM_SYNC_REQUEST protocol.
-#:
-#:     .. versionadded:: 1.1
 #: search_local_libs
 #:     If False, pyglet won't try to search for libraries in the script
 #:     directory and its `lib` subdirectory. This is useful to load a local
@@ -130,10 +121,9 @@ options = {
     'debug_x11': False,
     'shadow_window': True,
     'vsync': None,
-    'xsync': True,
-    'xlib_fullscreen_override_redirect': False,
     'search_local_libs': True,
     'win32_gdi_font': False,
+    'scale_with_dpi': False,
     'headless': False,
     'headless_device': 0,
     'win32_disable_shaping': False,
@@ -163,10 +153,9 @@ _option_types = {
     'debug_x11': bool,
     'shadow_window': bool,
     'vsync': bool,
-    'xsync': bool,
-    'xlib_fullscreen_override_redirect': bool,
     'search_local_libs': bool,
     'win32_gdi_font': bool,
+    'scale_with_dpi': bool,
     'headless': bool,
     'headless_device': int,
     'win32_disable_shaping': bool,
@@ -196,16 +185,15 @@ if compat_platform == 'cygwin':
     # DirectSound support.
     import ctypes
 
-    ctypes.windll = ctypes.cdll
-    ctypes.oledll = ctypes.cdll
+    ctypes.windll = ctypes.cdll  # type: ignore
+    ctypes.oledll = ctypes.cdll  # type: ignore
     ctypes.WINFUNCTYPE = ctypes.CFUNCTYPE
-    ctypes.HRESULT = ctypes.c_long
-
+    ctypes.HRESULT = ctypes.c_long  # type: ignore
 
 # Call tracing
 # ------------
 
-_trace_filename_abbreviations = {}
+_trace_filename_abbreviations: Dict[str, str] = {}
 _trace_thread_count = 0
 _trace_args = options['debug_trace_args']
 _trace_depth = options['debug_trace_depth']
@@ -301,7 +289,7 @@ def _install_trace():
 class _ModuleProxy:
     _module = None
 
-    def __init__(self, name):
+    def __init__(self, name: str):
         self.__dict__['_module_name'] = name
 
     def __getattr__(self, name):
@@ -333,20 +321,19 @@ class _ModuleProxy:
             setattr(module, name, value)
 
 
-# Lazily load all modules, except if performing
-# type checking or code inspection.
+# Lazily load all modules, except if performing type checking or code inspection.
 if TYPE_CHECKING:
     from . import app
-    from . import canvas
     from . import clock
     from . import customtypes
+    from . import display
     from . import event
     from . import font
     from . import gl
     from . import graphics
     from . import gui
-    from . import input
     from . import image
+    from . import input
     from . import lib
     from . import math
     from . import media
@@ -357,27 +344,26 @@ if TYPE_CHECKING:
     from . import text
     from . import window
 else:
-    app = _ModuleProxy('app')
-    canvas = _ModuleProxy('canvas')
-    clock = _ModuleProxy('clock')
-    customtypes = _ModuleProxy('customtypes')
-    event = _ModuleProxy('event')
-    font = _ModuleProxy('font')
-    gl = _ModuleProxy('gl')
-    graphics = _ModuleProxy('graphics')
-    gui = _ModuleProxy('gui')
-    image = _ModuleProxy('image')
-    input = _ModuleProxy('input')
-    lib = _ModuleProxy('lib')
-    math = _ModuleProxy('math')
-    media = _ModuleProxy('media')
-    model = _ModuleProxy('model')
-    resource = _ModuleProxy('resource')
-    sprite = _ModuleProxy('sprite')
-    shapes = _ModuleProxy('shapes')
-    text = _ModuleProxy('text')
-    window = _ModuleProxy('window')
-
+    app = _ModuleProxy('app')  # type: ignore
+    clock = _ModuleProxy('clock')  # type: ignore
+    customtypes = _ModuleProxy('customtypes')  # type: ignore
+    display = _ModuleProxy('display')
+    event = _ModuleProxy('event')  # type: ignore
+    font = _ModuleProxy('font')  # type: ignore
+    gl = _ModuleProxy('gl')  # type: ignore
+    graphics = _ModuleProxy('graphics')  # type: ignore
+    gui = _ModuleProxy('gui')  # type: ignore
+    image = _ModuleProxy('image')  # type: ignore
+    input = _ModuleProxy('input')  # type: ignore
+    lib = _ModuleProxy('lib')  # type: ignore
+    math = _ModuleProxy('math')  # type: ignore
+    media = _ModuleProxy('media')  # type: ignore
+    model = _ModuleProxy('model')  # type: ignore
+    resource = _ModuleProxy('resource')  # type: ignore
+    sprite = _ModuleProxy('sprite')  # type: ignore
+    shapes = _ModuleProxy('shapes')  # type: ignore
+    text = _ModuleProxy('text')  # type: ignore
+    window = _ModuleProxy('window')  # type: ignore
 
 # Call after creating proxies:
 if options['debug_trace']:

pyglet-2.1.dev1/pyglet/__init__.pyi

@@ -0,0 +1,13 @@
+from typing import Any, Tuple, Dict
+
+from . import app as app, canvas as canvas, clock as clock, customtypes as customtypes, font as font, gl as gl, \
+     graphics as graphics, gui as gui, image as image, input as input, math as math, media as media, model as model, \
+     resource as resource, shapes as shapes, sprite as sprite, text as text, window as window
+
+version: str
+MIN_PYTHON_VERSION: Tuple[int, int]
+MIN_PYTHON_VERSION_STR: str
+compat_platform: str
+env: str
+value: str
+options: Dict[str, Any]

{pyglet-2.0.14 → pyglet-2.1.dev1}/pyglet/app/__init__.py

@@ -29,14 +29,18 @@ default policy is to wait until all windows are closed)::
 .. versionadded:: 1.1
 """
 
-import platform
 import sys
 import weakref
+import platform
+
+from typing import Union
 
 import pyglet
+
 from pyglet import compat_platform
 from pyglet.app.base import EventLoop
 
+
 _is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
 if _is_pyglet_doc_run:
@@ -65,37 +69,38 @@ the set when they are no longer referenced or are closed explicitly.
 """
 
 
-def run(interval=1 / 60):
-    """Begin processing events, scheduled functions and window updates.
+def run(interval: Union[float, None] = 1/60) -> None:
+    """Begin processing events, scheduled functions, and window updates.
 
     This is a convenience function, equivalent to::
 
-        pyglet.app.event_loop.run()
+        pyglet.app.event_loop.run(interval)
 
     """
     event_loop.run(interval)
 
 
-def exit():
+def exit() -> None:
     """Exit the application event loop.
 
-    Causes the application event loop to finish, if an event loop is currently
-    running.  The application may not necessarily exit (for example, there may
-    be additional code following the `run` invocation).
+    Causes the application event loop to finish if it's currenting
+    running. This call does not specifically exit the application.
+    For example, there may be additional code following the `run`
+    invocation.
 
     This is a convenience function, equivalent to::
 
-        event_loop.exit()
+        pyglet.app.event_loop.exit()
 
     """
     event_loop.exit()
 
 
-#: The global event loop.  Applications can replace this
+#: The global event loop. Applications can replace this
 #: with their own subclass of :class:`EventLoop` before calling 
 #: :meth:`EventLoop.run`.
 event_loop = EventLoop()
 
-#: The platform-dependent event loop. Applications must not subclass
-# or replace this :class:`PlatformEventLoop` object.
+#: The platform-dependent event loop. Applications are strongly discouraged
+#: from subclassing or replacing this :class:`PlatformEventLoop` object.
 platform_event_loop = PlatformEventLoop()

{pyglet-2.0.14 → pyglet-2.1.dev1}/pyglet/app/base.py

@@ -2,6 +2,8 @@ import sys
 import queue
 import threading
 
+from typing import Union
+
 from pyglet import app
 from pyglet import clock
 from pyglet import event
@@ -119,7 +121,7 @@ class EventLoop(event.EventDispatcher):
             window.dispatch_event('on_refresh', dt)
             window.flip()
 
-    def run(self, interval=1/60):
+    def run(self, interval: Union[float, None] = 1/60) -> None:
         """Begin processing events, scheduled functions and window updates.
 
         :Parameters:
@@ -137,7 +139,7 @@ class EventLoop(event.EventDispatcher):
         implementation is platform-specific.
         """
         if interval is None:
-            # User application will manage a custom _redraw_windows() method
+            # User will schedule Window.draw manually
             pass
         elif interval == 0:
             self.clock.schedule(self._redraw_windows)

pyglet-2.1.dev1/pyglet/customtypes.py

@@ -0,0 +1,23 @@
+"""Holds type aliases used throughout the codebase."""
+import ctypes
+import sys
+
+from typing import Union, Literal
+
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    # Best-effort placeholder for older Python versions
+    Buffer = Union[bytes, bytearray, memoryview, ctypes.Array]
+
+HorizontalAlign = Literal["left", "center", "right"]
+AnchorX = Literal["left", "center", "right"]
+AnchorY = Literal["top", "bottom", "center", "baseline"]
+ContentVAlign = Literal["left", "center", "top"]
+
+
+
+__all__ = [
+    "Buffer", "HorizontalAlign", "AnchorX", "AnchorY", "ContentVAlign"
+]

{pyglet-2.0.14/pyglet/canvas → pyglet-2.1.dev1/pyglet/display}/__init__.py

@@ -1,11 +1,9 @@
 """Display and screen management.
 
-Rendering is performed on a :class:`Canvas`, which conceptually could be an
-off-screen buffer, the content area of a :class:`pyglet.window.Window`, or an
-entire screen. Currently, canvases can only be created with windows (though
-windows can be set fullscreen).
+Rendering is performed on the content area of a :class:`pyglet.window.Window`,
+or an entire screen.
 
-Windows and canvases must belong to a :class:`Display`. On Windows and Mac OS X
+Windows must belong to a :class:`Display`. On Microsoft Windows and macOS,
 there is only one display, which can be obtained with :func:`get_display`.
 Linux supports multiple displays, corresponding to discrete X11 display
 connections and screens.  :func:`get_display` on Linux returns the default
@@ -60,22 +58,22 @@ def get_display():
 
 
 if _is_pyglet_doc_run:
-    from pyglet.canvas.base import Display, Screen, Canvas, ScreenMode
+    from pyglet.display.base import Display, Screen, Canvas, ScreenMode
 else:
     from pyglet import compat_platform, options
     if options['headless']:
-        from pyglet.canvas.headless import HeadlessDisplay as Display
-        from pyglet.canvas.headless import HeadlessScreen as Screen
-        from pyglet.canvas.headless import HeadlessCanvas as Canvas
+        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.canvas.cocoa import CocoaDisplay as Display
-        from pyglet.canvas.cocoa import CocoaScreen as Screen
-        from pyglet.canvas.cocoa import CocoaCanvas as Canvas
+        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.canvas.win32 import Win32Display as Display
-        from pyglet.canvas.win32 import Win32Screen as Screen
-        from pyglet.canvas.win32 import Win32Canvas as Canvas
+        from pyglet.display.win32 import Win32Display as Display
+        from pyglet.display.win32 import Win32Screen as Screen
+        from pyglet.display.win32 import Win32Canvas as Canvas
     else:
-        from pyglet.canvas.xlib import XlibDisplay as Display
-        from pyglet.canvas.xlib import XlibScreen as Screen
-        from pyglet.canvas.xlib import XlibCanvas as Canvas
+        from pyglet.display.xlib import XlibDisplay as Display
+        from pyglet.display.xlib import XlibScreen as Screen
+        from pyglet.display.xlib import XlibCanvas as Canvas

{pyglet-2.0.14/pyglet/canvas → pyglet-2.1.dev1/pyglet/display}/base.py

@@ -1,28 +1,19 @@
 from pyglet import gl
 from pyglet import app
 from pyglet import window
-from pyglet import canvas
+from pyglet import display
 
 
 class Display:
-    """A display device supporting one or more screens.
-    
-    .. versionadded:: 1.2
-    """
+    """A display device supporting one or more screens."""
 
-    name = None
-    """Name of this display, if applicable.
-
-    :type: str
-    """
+    name: str = ""
+    """Name of this display, if applicable."""
 
-    x_screen = None
-    """The X11 screen number of this display, if applicable.
+    x_screen: int = None
+    """The X11 screen number of this display, if applicable."""
 
-    :type: int
-    """
-
-    def __init__(self, name=None, x_screen=None):
+    def __init__(self, name: str = "", x_screen: int = None):
         """Create a display connection for the given name and screen.
 
         On X11, :attr:`name` is of the form ``"hostname:display"``, where the
@@ -34,19 +25,13 @@ class Display:
         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
-        screen to be accessed through a single pyglet`~pyglet.canvas.Display`
+        screen to be accessed through a single pyglet`~pyglet.display.Display`
 
         On platforms other than X11, :attr:`name` and :attr:`x_screen` are 
         ignored; there is only a single display device on these systems.
 
-        :Parameters:
-            name : str
-                The name of the display to connect to.
-            x_screen : int
-                The X11 screen number to use.
-
         """
-        canvas._displays.add(self)
+        display._displays.add(self)
 
     def get_screens(self):
         """Get the available screens.
@@ -81,7 +66,7 @@ class Display:
 
         :rtype: sequence of :class:`~pyglet.window.Window`
         """
-        return [window for window in app.windows if window.display is self]
+        return [win for win in app.windows if window.display is self]
 
 
 class Screen:
@@ -106,7 +91,7 @@ class Screen:
         """
         
         :parameters:
-            `display` : `~pyglet.canvas.Display`
+            `display` : `~pyglet.display.Display`
                 :attr:`display`
             `x` : int
                 Left edge :attr:`x`
@@ -267,6 +252,20 @@ class Screen:
         """
         raise NotImplementedError('abstract')
 
+    def get_dpi(self):
+        """Get the DPI of the screen.
+
+        :rtype: int
+        """
+        raise NotImplementedError('abstract')
+
+    def get_scale(self):
+        """Get the pixel scale ratio of the screen.
+
+        :rtype: float
+        """
+        raise NotImplementedError('abstract')
+
 
 class ScreenMode:
     """Screen resolution and display settings.

{pyglet-2.0.14/pyglet/canvas → pyglet-2.1.dev1/pyglet/display}/cocoa.py

@@ -4,8 +4,12 @@ from ctypes import *
 
 from .base import Display, Screen, ScreenMode, Canvas
 
-from pyglet.libs.darwin.cocoapy import CGDirectDisplayID, quartz, cf
+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
+
+
+NSScreen = ObjCClass('NSScreen')
 
 
 class CocoaDisplay(Display):
@@ -31,28 +35,38 @@ class CocoaScreen(Screen):
         self._cg_display_id = displayID
         # Save the default mode so we can restore to it.
         self._default_mode = self.get_mode()
-
-    # FIX ME:
-    # This method is needed to get multi-monitor support working properly.
-    # However the NSScreens.screens() message currently sends out a warning:
-    # "*** -[NSLock unlock]: lock (<NSLock: 0x...> '(null)') unlocked when not locked"
-    # on Snow Leopard and apparently causes python to crash on Lion.
-    #
-    # def get_nsscreen(self):
-    #     """Returns the NSScreen instance that matches our CGDirectDisplayID."""
-    #     NSScreen = ObjCClass('NSScreen')
-    #     # Get a list of all currently active NSScreens and then search through
-    #     # them until we find one that matches our CGDisplayID.
-    #     screen_array = NSScreen.screens()
-    #     count = screen_array.count()
-    #     for i in range(count):
-    #         nsscreen = screen_array.objectAtIndex_(i)
-    #         screenInfo = nsscreen.deviceDescription()
-    #         displayID = screenInfo.objectForKey_(get_NSString('NSScreenNumber'))
-    #         displayID = displayID.intValue()
-    #         if displayID == self._cg_display_id:
-    #             return nsscreen
-    #     return None
+        self._ns_screen = self.get_nsscreen()
+
+    def get_nsscreen(self):
+        """Returns the NSScreen instance that matches our CGDirectDisplayID."""
+        # Get a list of all currently active NSScreens and then search through
+        # them until we find one that matches our CGDisplayID.
+        screen_array = NSScreen.screens()
+        count = screen_array.count()
+        for i in range(count):
+            nsscreen = screen_array.objectAtIndex_(i)
+            screenInfo = nsscreen.deviceDescription()
+            displayID = screenInfo.objectForKey_(get_NSString('NSScreenNumber'))
+            displayID = displayID.intValue()
+            if displayID == self._cg_display_id:
+                return nsscreen
+        return None
+
+    def get_dpi(self):
+        desc = self._ns_screen.deviceDescription()
+        rsize = desc.objectForKey_(NSDeviceResolution).sizeValue()
+        return int(rsize.width)
+
+    def get_scale(self):
+        ratio = 1.0
+        if self._ns_screen:
+            pts = self._ns_screen.frame()
+            pixels = self._ns_screen.convertRectToBacking_(pts)
+            ratio = pixels.size.width / pts.size.width
+        else:
+            print("Could not initialize NSScreen to retrieve DPI. Using default.")
+
+        return ratio
 
     def get_matching_configs(self, template):
         canvas = CocoaCanvas(self.display, self, None)

{pyglet-2.0.14/pyglet/canvas → pyglet-2.1.dev1/pyglet/display}/win32.py

@@ -1,11 +1,27 @@
 from .base import Display, Screen, ScreenMode, Canvas
 
-from pyglet.libs.win32 import _user32
+from pyglet.libs.win32 import _user32, _shcore, _gdi32
 from pyglet.libs.win32.constants import *
 from pyglet.libs.win32.types import *
 from pyglet.libs.win32.context_managers import device_context
 
 
+def set_dpi_awareness():
+    """
+       Setting DPI varies per Windows version.
+       Note: DPI awareness needs to be set before Window, Display, or Screens are initialized.
+    """
+    if WINDOWS_10_CREATORS_UPDATE_OR_GREATER:
+        _user32.SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2)
+    elif WINDOWS_8_1_OR_GREATER:  # 8.1 and above allows per monitor DPI.
+        _shcore.SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE)
+    elif WINDOWS_VISTA_OR_GREATER:  # Only System wide DPI
+        _user32.SetProcessDPIAware()
+
+
+set_dpi_awareness()
+
+
 class Win32Display(Display):
     def get_screens(self):
         screens = []
@@ -46,6 +62,24 @@ class Win32Screen(Screen):
         _user32.GetMonitorInfoW(self._handle, byref(info))
         return info.szDevice
 
+    def get_dpi(self):
+        if WINDOWS_8_1_OR_GREATER:
+            xdpi = UINT()
+            ydpi = UINT()
+            _shcore.GetDpiForMonitor(self._handle, 0, byref(xdpi), byref(ydpi))
+            xdpi, ydpi = xdpi.value, ydpi.value
+        else:
+            dc = _user32.GetDC(None)
+            xdpi = _gdi32.GetDeviceCaps(dc, LOGPIXELSX)
+            ydpi = _gdi32.GetDeviceCaps(dc, LOGPIXELSY)
+            _user32.ReleaseDC(0, dc)
+
+        return xdpi
+
+    def get_scale(self):
+        xdpi = self.get_dpi()
+        return xdpi / USER_DEFAULT_SCREEN_DPI
+
     def get_modes(self):
         device_name = self.get_device_name()
         i = 0

{pyglet-2.0.14/pyglet/canvas → pyglet-2.1.dev1/pyglet/display}/xlib.py

@@ -1,6 +1,8 @@
 import ctypes
 from ctypes import *
 
+from pyglet.util import asbytes
+
 from pyglet import app
 from pyglet.app.xlib import XlibSelectDevice
 from .base import Display, Screen, ScreenMode, Canvas
@@ -177,6 +179,28 @@ class XlibScreen(Screen):
         super(XlibScreen, self).__init__(display, x, y, width, height)
         self._xinerama = xinerama
 
+    def get_dpi(self):
+        resource = xlib.XResourceManagerString(self.display._display)
+        dpi = 96
+        if resource:
+            xlib.XrmInitialize()
+
+            db = xlib.XrmGetStringDatabase(resource)
+            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 value.addr and rs_type.value == b'String':
+                        dpi = int(value.addr)
+
+                xlib.XrmDestroyDatabase(db)
+
+        return dpi
+
+    def get_scale(self):
+        return self.get_dpi() / 96
+
     def get_matching_configs(self, template):
         canvas = XlibCanvas(self.display, None)
         configs = template.match(canvas)

{pyglet-2.0.14 → pyglet-2.1.dev1}/pyglet/font/__init__.py

@@ -98,6 +98,7 @@ def have_font(name: str) -> bool:
 def load(name: Optional[Union[str, Iterable[str]]] = None, size: Optional[float] = None, bold: bool = False,
          italic: bool = False, stretch: bool = False, dpi: Optional[float] = None):
     """Load a font for rendering.
+
     :Parameters:
         `name` : str, or list of str
             Font family, for example, "Times New Roman".  If a list of names

{pyglet-2.0.14 → pyglet-2.1.dev1}/pyglet/gl/__init__.py

@@ -50,7 +50,7 @@ from pyglet.gl import gl_info
 from pyglet.gl.gl_compat import GL_LUMINANCE, GL_INTENSITY
 
 from pyglet import compat_platform
-from .base import ObjectSpace, CanvasConfig, Context
+from .base import ObjectSpace, DisplayConfig, Context
 
 import sys as _sys
 _is_pyglet_doc_run = hasattr(_sys, "is_pyglet_doc_run") and _sys.is_pyglet_doc_run
@@ -162,6 +162,10 @@ def _create_shadow_window():
             """Shadow window does not need a projection."""
             pass
 
+        def on_resize(self, width, height):
+            """No projection and not required."""
+            pass
+
     _shadow_window = ShadowWindow()
     _shadow_window.switch_to()