pyglet 2.1.2__py3-none-any.whl → 2.1.4__py3-none-any.whl

pyglet/__init__.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.2'
+version = '2.1.4'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -110,6 +110,10 @@ class Options:
     debug_trace_depth: int = 1
     debug_trace_flush: bool = True
 
+    debug_com: bool = False
+    """If ``True``, prints information on COM calls. This can potentially help narrow down issues with certain libraries
+    that utilize COM calls. Only applies to the Windows platform."""
+
     debug_win32: bool = False
     """If ``True``, prints error messages related to Windows library calls. Usually get's information from
     ``Kernel32.GetLastError``. This information is output to a file called ``debug_win32.log``."""
@@ -175,6 +179,11 @@ class Options:
     .. versionadded:: 2.0
     """
 
+    text_antialiasing: bool = True
+    """If ``True``, font renderers will improve text quality by adding antialiasing to the rendered characters. If
+    ``False``, text quality will appear pixelated.
+    """
+
     headless: bool = False
     """If ``True``, visible Windows are not created and a running desktop environment is not required. This option
     is useful when running pyglet on a headless server, or compute cluster. OpenGL drivers with ``EGL`` support are
@@ -186,14 +195,17 @@ class Options:
     GPU to use. This is only useful on multi-GPU systems.
     """
 
-    win32_disable_shaping: bool = False
-    """If ``True``, will disable the shaping process for the default Windows font renderer to offer a performance
-    speed up. If your font is simple, monospaced, or you require no advanced OpenType features, this option may be
-    useful. You can try enabling this to see if there is any impact on clarity for your font. The advance will be
-    determined by the glyph width.
+    text_shaping: Literal["platform", "harfbuzz", False] = 'platform'
+    """Determines how text is processed and displayed based on features of the font.
 
-    .. note:: Shaping is the process of determining which character glyphs to use and specific placements of those
-       glyphs when given a full string of characters.
+    Valid option names are:
+
+     * ``False``, Disables the shaping process for text. This may increase performance as it reduces the amount
+        of calls during rendering. If your font is simple, monospaced, or you require no advanced OpenType features,
+        this option may be useful.
+     * ``'platform'``, Uses platform's font system for shaping. Supported by Windows (DirectWrite) and Mac (CoreText).
+     * ``'harfbuzz'``, Utilize the harfbuzz library for font shaping. This requires an optional dependency, if not
+     found, it will fallback to platform shaping.
 
     .. versionadded:: 2.0
     """
@@ -270,7 +282,7 @@ class Options:
     rescaling and repositioning of content will be necessary, but at the cost of blurry content depending on the extent
     of the stretch. For example, 800x600 at 150% DPI will be 800x600 for `window.get_size()` and 1200x900 for
     `window.get_framebuffer_size()`.
-    
+
     `'platform'`: A DPI aware window is created, however window sizing and framebuffer sizing is not interfered with
     by Pyglet. Final sizes are dictated by the platform the window was created on. It is up to the user to make any
     platform adjustments themselves such as sizing on a platform, mouse coordinate adjustments, or framebuffer size

pyglet/__init__.pyi

@@ -49,15 +49,17 @@ class Options:
     debug_win32: bool
     debug_input: bool
     debug_x11: bool
+    debug_com: bool
     shadow_window: bool
     vsync: bool | None
     xsync: bool
     xlib_fullscreen_override_redirect: bool
     search_local_libs: bool
     win32_gdi_font: bool
+    text_antialiasing: bool
     headless: bool
     headless_device: int
-    win32_disable_shaping: bool
+    text_shaping: Literal["platform", "harfbuzz", False]
     dw_legacy_naming: bool
     win32_disable_xinput: bool
     com_mta: bool

pyglet/app/cocoa.py

@@ -113,8 +113,10 @@ class CocoaAlternateEventLoop(EventLoop):
         super().__init__()
         self.platform_event_loop = None
 
-    def run(self, interval=1/60):
-        if not interval:
+    def run(self, interval: float | None = 1/60):
+        if interval is None:
+            pass  # do not schedule redraws
+        elif not interval:
             self.clock.schedule(self._redraw_windows)
         else:
             self.clock.schedule_interval(self._redraw_windows, interval)
@@ -133,7 +135,8 @@ class CocoaAlternateEventLoop(EventLoop):
 
         self.dispatch_event('on_enter')
         self.is_running = True
-        self.platform_event_loop.nsapp_start(interval)
+
+        self.platform_event_loop.nsapp_start(interval or 0)
 
     def exit(self):
         """Safely exit the event loop at the end of the current iteration.

pyglet/app/xlib.py

@@ -54,7 +54,7 @@ class NotificationDevice(XlibSelectDevice):
 
 class XlibEventLoop(PlatformEventLoop):
     def __init__(self):
-        super(XlibEventLoop, self).__init__()
+        super().__init__()
         self._notification_device = NotificationDevice()
         self.select_devices = set()
         self.select_devices.add(self._notification_device)

pyglet/display/cocoa.py

@@ -31,7 +31,7 @@ class CocoaScreen(Screen):
         # http://www.cocoabuilder.com/archive/cocoa/233492-ns-cg-rect-conversion-and-screen-coordinates.html
         x, y = bounds.origin.x, bounds.origin.y
         width, height = bounds.size.width, bounds.size.height
-        super(CocoaScreen, self).__init__(display, int(x), int(y), int(width), int(height))
+        super().__init__(display, int(x), int(y), int(width), int(height))
         self._cg_display_id = displayID
         # Save the default mode so we can restore to it.
         self._default_mode = self.get_mode()
@@ -111,7 +111,7 @@ class CocoaScreen(Screen):
 class CocoaScreenMode(ScreenMode):
 
     def __init__(self, screen, cgmode):
-        super(CocoaScreenMode, self).__init__(screen)
+        super().__init__(screen)
         quartz.CGDisplayModeRetain(cgmode)
         self.cgmode = cgmode
         self.width = int(quartz.CGDisplayModeGetWidth(cgmode))

pyglet/display/win32.py

@@ -1,35 +1,34 @@
-from .base import Display, Screen, ScreenMode, Canvas
+from ctypes import byref, sizeof
 
-from pyglet.libs.win32 import _user32, _shcore, _gdi32
+from pyglet.libs.win32 import _gdi32, _shcore, _user32
 from pyglet.libs.win32.constants import (
     CDS_FULLSCREEN,
     DISP_CHANGE_SUCCESSFUL,
     ENUM_CURRENT_SETTINGS,
-    WINDOWS_8_1_OR_GREATER,
-    WINDOWS_VISTA_OR_GREATER,
-    WINDOWS_10_CREATORS_UPDATE_OR_GREATER,
-    USER_DEFAULT_SCREEN_DPI,
     LOGPIXELSX,
     LOGPIXELSY,
-
+    USER_DEFAULT_SCREEN_DPI,
+    WINDOWS_8_1_OR_GREATER,
+    WINDOWS_10_CREATORS_UPDATE_OR_GREATER,
+    WINDOWS_VISTA_OR_GREATER,
 )
+from pyglet.libs.win32.context_managers import device_context
 from pyglet.libs.win32.types import (
     DEVMODE,
     DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2,
-    MONITORINFOEX,
     MONITORENUMPROC,
+    MONITORINFOEX,
     PROCESS_PER_MONITOR_DPI_AWARE,
     UINT,
-    sizeof,
-    byref
 )
-from pyglet.libs.win32.context_managers import device_context
 
+from .base import Canvas, Display, Screen, ScreenMode
 
-def set_dpi_awareness():
-    """
-       Setting DPI varies per Windows version.
-       Note: DPI awareness needs to be set before Window, Display, or Screens are initialized.
+
+def set_dpi_awareness() -> None:
+    """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)
@@ -63,7 +62,7 @@ class Win32Screen(Screen):
     _initial_mode = None
 
     def __init__(self, display, handle, x, y, width, height):
-        super(Win32Screen, self).__init__(display, x, y, width, height)
+        super().__init__(display, x, y, width, height)
         self._handle = handle
 
     def get_matching_configs(self, template):
@@ -145,7 +144,7 @@ class Win32Screen(Screen):
 
 class Win32ScreenMode(ScreenMode):
     def __init__(self, screen, mode):
-        super(Win32ScreenMode, self).__init__(screen)
+        super().__init__(screen)
         self._mode = mode
         self.width = mode.dmPelsWidth
         self.height = mode.dmPelsHeight
@@ -158,6 +157,6 @@ class Win32ScreenMode(ScreenMode):
 
 class Win32Canvas(Canvas):
     def __init__(self, display, hwnd, hdc):
-        super(Win32Canvas, self).__init__(display)
+        super().__init__(display)
         self.hwnd = hwnd
         self.hdc = hdc

pyglet/display/xlib.py

@@ -96,7 +96,7 @@ class XlibDisplay(XlibSelectDevice, Display):
         if x_screen >= screen_count:
             raise NoSuchDisplayException(f'Display "{name}" has no screen {x_screen:d}')
 
-        super(XlibDisplay, self).__init__()
+        super().__init__()
         self.name = name
         self.x_screen = x_screen
 
@@ -276,7 +276,7 @@ class XlibScreenMode(ScreenMode):
         self.info = info
         self.width = info.hdisplay
         self.height = info.vdisplay
-        self.rate = info.dotclock
+        self.rate = (info.dotclock * 1000) / (info.htotal * info.vtotal)
         self.depth = None
 
 

pyglet/display/xlib_vidmoderestore.py

@@ -165,7 +165,7 @@ def set_initial_mode(mode):
     if (display, screen) in _restorable_screens:
         return
 
-    packet = ModePacket(display, screen, mode.width, mode.height, mode.rate)
+    packet = ModePacket(display, screen, mode.width, mode.height, mode.info.dotclock)
 
     os.write(_mode_write_pipe, packet.encode())
     _restorable_screens.add((display, screen))

pyglet/extlibs/earcut.py

@@ -473,8 +473,8 @@ def sortLinked(_list):
 # z-order of a point given coords and size of the data bounding box
 def zOrder(x, y, minX, minY, size):
     # coords are transformed into non-negative 15-bit integer range
-    x = 32767 * (x - minX) // size
-    y = 32767 * (y - minY) // size
+    x = int(32767 * (x - minX) / size)
+    y = int(32767 * (y - minY) / size)
 
     x = (x | (x << 8)) & 0x00FF00FF
     x = (x | (x << 4)) & 0x0F0F0F0F

pyglet/font/__init__.py

@@ -42,7 +42,7 @@ def _get_system_font_class() -> type[Font]:
     elif pyglet.compat_platform in ("win32", "cygwin"):
         from pyglet.libs.win32.constants import WINDOWS_7_OR_GREATER
         if WINDOWS_7_OR_GREATER and not pyglet.options["win32_gdi_font"]:
-            from pyglet.font.directwrite import Win32DirectWriteFont
+            from pyglet.font.dwrite import Win32DirectWriteFont
             _font_class = Win32DirectWriteFont
         else:
             from pyglet.font.win32 import GDIPlusFont
@@ -194,7 +194,7 @@ if not getattr(sys, "is_pyglet_doc_run", False):
     _user_fonts = []
 
 
-def add_file(font: str | BinaryIO) -> None:
+def add_file(font: str | BinaryIO | bytes) -> None:
     """Add a font to pyglet's search path.
 
     In order to load a font that is not installed on the system, you must
@@ -208,7 +208,7 @@ def add_file(font: str | BinaryIO) -> None:
 
     Args:
         font:
-            Filename or file-like object to load fonts from.
+            Filename, file-like object, or bytes to load fonts from.
 
     """
     if isinstance(font, str):

pyglet/font/base.py

@@ -7,66 +7,66 @@ 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 pyglet import image
 from pyglet.gl import GL_LINEAR, GL_RGBA, GL_TEXTURE_2D
 
-_other_grapheme_extend = list(map(chr, [0x09be, 0x09d7, 0x0be3, 0x0b57, 0x0bbe, 0x0bd7, 0x0cc2,
-                                        0x0cd5, 0x0cd6, 0x0d3e, 0x0d57, 0x0dcf, 0x0ddf, 0x200c,
-                                        0x200d, 0xff9e, 0xff9f]))  # skip codepoints above U+10000
-_logical_order_exception = list(map(chr, list(range(0xe40, 0xe45)) + list(range(0xec0, 0xec4))))
+_OTHER_GRAPHEME_EXTEND = {
+    chr(x) for x in [0x09be, 0x09d7, 0x0be3, 0x0b57, 0x0bbe, 0x0bd7, 0x0cc2,
+                     0x0cd5, 0x0cd6, 0x0d3e, 0x0d57, 0x0dcf, 0x0ddf, 0x200c,
+                     0x200d, 0xff9e, 0xff9f]
+}  # skip codepoints above U+10000
+_LOGICAL_ORDER_EXCEPTION = {chr(x) for x in range(0xe40, 0xe45)} | {chr(x) for x in range(0xec0, 0xec4)}
 
-_grapheme_extend = lambda c, cc: cc in ("Me", "Mn") or c in _other_grapheme_extend
+_EXTEND_CHARS = {chr(x) for x in [0xe30, 0xe32, 0xe33, 0xe45, 0xeb0, 0xeb2, 0xeb3]}
 
 _CR = "\u000d"
 _LF = "\u000a"
-_control = lambda c, cc: cc in ("ZI", "Zp", "Cc", "Cf") and c not in list(map(chr, [0x000d, 0x000a, 0x200c, 0x200d]))
-_extend = lambda c, cc: _grapheme_extend(c, cc) or \
-                        c in list(map(chr, [0xe30, 0xe32, 0xe33, 0xe45, 0xeb0, 0xeb2, 0xeb3]))
-_prepend = lambda c, cc: c in _logical_order_exception  # noqa: ARG005
-_spacing_mark = lambda c, cc: cc == "Mc" and c not in _other_grapheme_extend
+
+_CATEGORY_EXTEND = {"Me", "Mn"}
+_CATEGORY_CONTROL = {"ZI", "Zp", "Cc", "Cf"}
+_CATEGORY_SPACING_MARK = {"Mc"}
 
 
-def grapheme_break(left: str, right: str) -> bool:  # noqa: D103
+def grapheme_break(left: str, left_cc: str, right: str, right_cc: str) -> bool:
+    """Determines if there should be a break between characters."""
     # GB1
     if left is None:
         return True
 
     # GB2 not required, see end of get_grapheme_clusters
 
-    # GB3
+    # GB3: CR + LF do not break
     if left == _CR and right == _LF:
         return False
 
-    left_cc = unicodedata.category(left)
-
-    # GB4
-    if _control(left, left_cc):
+    # GB4: Break before Control characters
+    if left_cc in _CATEGORY_CONTROL and left not in _OTHER_GRAPHEME_EXTEND:
         return True
 
-    right_cc = unicodedata.category(right)
-
-    # GB5
-    if _control(right, right_cc):
+    # GB5: Break after Control characters
+    if right_cc in _CATEGORY_CONTROL and right not in _OTHER_GRAPHEME_EXTEND:
         return True
 
     # GB6, GB7, GB8 not implemented
 
-    # GB9
-    if _extend(right, right_cc):
+    # GB9: Do not break before Extend characters
+    if right_cc in _CATEGORY_EXTEND or right in _EXTEND_CHARS:
         return False
 
-    # GB9a
-    if _spacing_mark(right, right_cc):
+    # GB9a: Do not break before SpacingMark characters
+    if right_cc == "Mc" and right not in _OTHER_GRAPHEME_EXTEND:
         return False
 
-    # GB9b
-    if _prepend(left, left_cc):
+    # GB9b: Do not break after Prepend characters
+    if left in _LOGICAL_ORDER_EXCEPTION:  # noqa: SIM103
         return False
 
-    # GB10
+    # GB999: Default to break
     return True
 
 
@@ -83,24 +83,38 @@ def get_grapheme_clusters(text: str) -> list[str]:
          List of Unicode grapheme clusters.
     """
     clusters = []
-    cluster = ""
+    cluster_chars = []
     left = None
+    left_cc = None
+
     for right in text:
-        if cluster and grapheme_break(left, right):
-            clusters.append(cluster)
-            cluster = ""
-        elif cluster:
-            # Add a zero-width space to keep len(clusters) == len(text)
-            clusters.append("\u200b")
-        cluster += right
+        right_cc = unicodedata.category(right)
+
+        if cluster_chars and grapheme_break(left, left_cc, right, right_cc):
+            clusters.append("".join(cluster_chars))
+            cluster_chars.clear()
+
+        cluster_chars.append(right)
         left = right
+        left_cc = right_cc
+
+    if cluster_chars:
+        clusters.append("".join(cluster_chars))
 
-    # GB2
-    if cluster:
-        clusters.append(cluster)
     return clusters
 
 
+#: :meta private:
+@dataclass
+class GlyphPosition:
+    """Positioning offsets for a glyph."""
+    __slots__ = ('x_advance', 'x_offset', 'y_advance', 'y_offset')
+    x_advance: int  # How far the line advances AFTER drawing horizontal.
+    y_advance: int  # How far the line advances AFTER drawing vertical.
+    x_offset: int  # How much the current glyph moves on the X-axis when drawn. Does not advance.
+    y_offset: int  # How much the current glyph moves on the Y-axis when drawn. Does not advance.
+
+
 class Glyph(image.TextureRegion):
     """A single glyph located within a larger texture.
 
@@ -116,8 +130,7 @@ class Glyph(image.TextureRegion):
     #: :If a glyph is colored by the font renderer, such as an emoji, it may be treated differently by pyglet.
     colored = False
 
-    def set_bearings(self, baseline: int, left_side_bearing: int, advance: int, x_offset: int = 0,
-                     y_offset: int = 0) -> None:
+    def set_bearings(self, baseline: int, left_side_bearing: int, advance: int) -> None:
         """Set metrics for this glyph.
 
         Args:
@@ -127,20 +140,16 @@ class Glyph(image.TextureRegion):
                 Distance to add to the left edge of the glyph.
             advance:
                 Distance to move the horizontal advance to the next glyph, in pixels.
-            x_offset:
-                Distance to move the glyph horizontally from its default position.
-            y_offset:
-                Distance to move the glyph vertically from its default position.
         """
         self.baseline = baseline
         self.lsb = left_side_bearing
         self.advance = advance
 
         self.vertices = (
-            left_side_bearing + x_offset,
-            -baseline + y_offset,
-            left_side_bearing + self.width + x_offset,
-            -baseline + self.height + y_offset)
+            left_side_bearing,
+            -baseline,
+            left_side_bearing + self.width,
+            -baseline + self.height)
 
 
 class GlyphTexture(image.Texture):
@@ -191,6 +200,7 @@ class GlyphRenderer(abc.ABC):
         Args:
             font: The :py:class:`~pyglet.font.base.Font` object to be rendered.
         """
+        self.font = font
 
     @abc.abstractmethod
     def render(self, text: str) -> Glyph:
@@ -203,6 +213,15 @@ class GlyphRenderer(abc.ABC):
              A Glyph with the proper metrics for that specific character.
         """
 
+    def create_zero_glyph(self) -> Glyph:
+        """Zero glyph is a 1x1 image that has a -1 advance.
+
+        This is to fill in for potential substitutions since font system requires 1 glyph per character in a string.
+        """
+        image_data = image.ImageData(1, 1, 'RGBA', bytes([0, 0, 0, 0]))
+        glyph = self.font.create_glyph(image_data)
+        glyph.set_bearings(-self.font.descent, 0, -1)
+        return glyph
 
 class FontException(Exception):  # noqa: N818
     """Generic exception related to errors from the font module.  Typically, from invalid font data."""
@@ -240,7 +259,7 @@ class Font:
             ``GL_NEAREST`` to prevent aliasing with pixelated fonts.
     """
     #: :meta private:
-    glyphs: dict[str, Glyph]
+    glyphs: dict[str | int, Glyph]
 
     texture_width: int = 512
     texture_height: int = 512
@@ -264,10 +283,47 @@ class Font:
     # The default type of texture bins. Should not be overridden by users.
     texture_class: ClassVar[type[GlyphTextureBin]] = GlyphTextureBin
 
+    # A list of fallback fonts to use when an existing glyph is not found.
+    fallbacks: list[Font]
+
+    _glyph_renderer: GlyphRenderer | None
+    _missing_glyph: Glyph | None
+    _zero_glyph: Glyph | None
+
+    # The size of the font in pixels.
+    pixel_size: float
+
     def __init__(self) -> None:
         """Initialize a font that can be used with Pyglet."""
         self.texture_bin = None
+        self.hb_resource =  None
+        self._glyph_renderer = None
+
+        # Represents a missing glyph.
+        self._missing_glyph = None
+
+        # Represents a zero width glyph.
+        self._zero_glyph = None
         self.glyphs = {}
+        self.fallbacks = []
+
+    def _initialize_renderer(self) -> None:
+        """Initialize the glyph renderer and cache it on the Font.
+
+        This way renderers for fonts that have been loaded but not used will not have unnecessary loaders.
+        """
+        if not self._glyph_renderer:
+            self._glyph_renderer = self.glyph_renderer_class(self)
+            self._missing_glyph = self._glyph_renderer.render(" ")
+            self._zero_glyph = self._glyph_renderer.create_zero_glyph()
+
+    def add_fallback(self, font: Font) -> None:
+        assert font not in self.fallbacks, "Font is already added."
+        self.fallbacks.append(font)
+
+    def remove_fallback(self, font: Font) -> None:
+        assert font not in self.fallbacks, "Font has not been added."
+        self.fallbacks.remove(font)
 
     @property
     @abc.abstractmethod
@@ -346,7 +402,7 @@ class Font:
 
         return atlas_size
 
-    def get_glyphs(self, text: str) -> list[Glyph]:
+    def get_glyphs(self, text: str) -> tuple[list[Glyph], list[GlyphPosition]]:
         """Create and return a list of Glyphs for `text`.
 
         If any characters do not have a known glyph representation in this
@@ -357,7 +413,9 @@ class Font:
                 Text to render.
         """
         glyph_renderer = None
+
         glyphs = []  # glyphs that are committed.
+        offsets = []
         for c in get_grapheme_clusters(str(text)):
             # Get the glyph for 'c'.  Hide tabs (Windows and Linux render
             # boxes)
@@ -368,7 +426,16 @@ class Font:
                     glyph_renderer = self.glyph_renderer_class(self)
                 self.glyphs[c] = glyph_renderer.render(c)
             glyphs.append(self.glyphs[c])
-        return glyphs
+            offsets.append(GlyphPosition(0, 0, 0, 0))
+
+        return glyphs, offsets
+
+    @abc.abstractmethod
+    def get_text_size(self, text: str) -> tuple[int, int]:
+        """Return's an estimated width and height of text using glyph metrics without rendering..
+
+        This does not take into account any shaping.
+        """
 
     def get_glyphs_for_width(self, text: str, width: int) -> list[Glyph]:
         """Return a list of glyphs for ``text`` that fit within the given width.