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

pyglet/font/group.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import pyglet
+from pyglet.font import base
+
+if TYPE_CHECKING:
+    from pyglet.enums import Weight, Style, Stretch
+
+
+@dataclass(frozen=True)
+class _RangeEntry:
+    start: int
+    end:   int
+    family: str
+
+
+class FontGroup:
+    """A collection of fonts that can be used like a single font.
+
+    Each font can be assigned a range of Unicode values that it is set to handle.
+
+    .. versionadded:: 3.0
+    """
+    _instance_cache: dict[tuple[float,  str | Weight, str | Style, str | Stretch, int], FontGroupInstance]
+    _ranges: list[_RangeEntry]
+
+    def __init__(self, name: str) -> None:
+        """Create a new font group.
+
+        Args:
+            name:
+                A unique name describing the grouping; must be unique enough to not collide with an existing font.
+        """
+        self.name = name
+        self._ranges = []
+        self._instance_cache = {}
+
+    def add(self, family: str, start: int | str, end: int | str) -> FontGroup:
+        """Add a font family responsible for a range of characters.
+
+        The first match will be used by layouts.
+
+        Args:
+            family:
+                The name of the font family for this range.
+            start:
+                The start of the range. This may be a single-character string or an integer corresponding to a Unicode
+                code point.
+            end:
+                The end of the range. This may be a single-character string or an integer corresponding to a Unicode
+                code point.
+
+        Returns:
+            This existing font group instance.
+        """
+        self._ranges.append(_RangeEntry(start, end, family))
+        return self
+
+    def get_font(self,
+                 size: float | None,
+                 weight: str | None = "normal",
+                 style: str | None = "normal",
+                 stretch: str | None = "normal",
+                 dpi: int | None = None,
+    ) -> FontGroupInstance:
+        size = size or 12
+        dpi = dpi or 96
+        weight = weight or Weight.NORMAL
+        style = style or Style.NORMAL
+        stretch = stretch or Stretch.NORMAL
+
+        descriptor = (size, weight, style, stretch, dpi)
+        inst = self._instance_cache.get(descriptor)
+        if inst is None:
+            inst = FontGroupInstance(self, size, weight, style, stretch, dpi)
+            self._instance_cache[descriptor] = inst
+        return inst
+
+    def _family_for_char(self, ch: str) -> str | None:
+        cp = ord(ch)
+        for r in self._ranges:
+            if r.start <= cp <= r.end:
+                return r.family
+        return None
+
+class FontGroupInstance(base.Font):
+    """A font instance based off the FontGroup."""
+    _child_cache: dict[str, base.Font]
+
+    def __init__(self, group: FontGroup, size: float, weight: str | Weight, style: str | Style,  # noqa: D107
+                 stretch: str | Stretch,  dpi: int | None) -> None:
+        super().__init__("", size, weight, style, stretch, dpi)
+        self._name = self._get_name()
+        self._group = group
+
+        self._child_cache = {}
+        self.glyphs.clear()  # This itself doesn't own glyphs
+
+    def _get_name(self) -> str:
+        """Generates a unique descriptor name for this instance."""
+        ital = "Italic" if self.style else "Regular"
+        return f"{self.name} ({int(self.size)}px {ital} w{self.weight} s{self.stretch} @{self.dpi}dpi)"
+
+    def _resolve_child(self, family: str) -> base.Font:
+        f = self._child_cache.get(family)
+        if f is None:
+            f = pyglet.font.load(family,
+                                 size=self.size,
+                                 weight=self.weight,
+                                 style=self.style,
+                                 stretch=self.stretch,
+                                 dpi=self.dpi)
+            self._child_cache[family] = f
+
+            self.ascent = max(self.ascent, getattr(f, "ascent", 0))
+            self.descent = max(self.descent, getattr(f, "descent", 0))
+        return f
+
+    def _font_for_cluster(self, cluster: str) -> base.Font | None:
+        if not cluster:
+            return None
+        ft_fam = self._group._family_for_char(cluster[0])  # noqa: SLF001
+        if ft_fam is None and self._group._ranges:  # noqa: SLF001
+            # Default to first font in the group if nothing matches
+            fam = self._group._ranges[0].family  # noqa: SLF001
+        return self._resolve_child(ft_fam) if ft_fam else None
+
+    def get_glyphs(self, text: str, shaping: bool = False) -> tuple[list[base.Glyph], list[base.GlyphPosition]]:
+        glyphs: list[base.Glyph] = []
+        offsets: list[base.GlyphPosition] = []
+
+        for cluster in base.get_grapheme_clusters(str(text)):
+            c = " " if cluster == "\t" else cluster
+            fnt = self._font_for_cluster(c)
+            if fnt is None:
+                self._initialize_renderer()
+                gs = self._missing_glyph or self._glyph_renderer.render(" ")
+                gp = base.GlyphPosition(0, 0, 0, 0)
+                glyphs.append(gs)
+                offsets.append(gp)
+            else:
+                gs, gp = fnt.get_glyphs(c, shaping)
+                glyphs.extend(gs)
+                offsets.extend(gp)
+
+        return glyphs, offsets
+
+    def get_text_size(self, text: str) -> tuple[int, int]:
+        if not text:
+            return 0, 0
+
+        total_w = 0
+        max_ascent = self.ascent
+        max_descent = self.descent
+
+        run_font: base.Font | None = None
+        run_text: list[str] = []
+
+        def flush() -> None:
+            nonlocal total_w, max_ascent, max_descent, run_font, run_text
+            if run_font and run_text:
+                w, _ = run_font.get_text_size("".join(run_text))
+                total_w += w
+                max_ascent = max(max_ascent, getattr(run_font, "ascent", 0))
+                max_descent = max(max_descent, getattr(run_font, "descent", 0))
+            run_font = None
+            run_text = []
+
+        for cluster in base.get_grapheme_clusters(text):
+            f = self._font_for_cluster(cluster)
+            if f is not run_font:
+                flush()
+                run_font = f
+            run_text.append(" " if cluster == "\t" else cluster)
+
+        flush()
+        return (total_w, max_ascent + max_descent)

pyglet/font/harfbuzz/__init__.py

@@ -51,7 +51,7 @@ elif sys.maxunicode == 0xFFFF:  # UTF-16
 
 def get_resource_from_ct_font(font: QuartzFont):
     """Get a harfbuzz resource object from a CoreText (Mac) font."""
-    key = (font.name, font.weight, font.italic, font.stretch)
+    key = (font.name, font.weight, font.style, font.stretch)
     if key in _hb_cache:
         return _hb_cache[key]
 
@@ -64,7 +64,7 @@ def get_resource_from_ct_font(font: QuartzFont):
 
 def get_resource_from_dw_font(font: Win32DirectWriteFont) -> _HarfbuzzResources:
     """Get a harfbuzz resource object from a DirectWrite (Windows) font."""
-    key = (font.name, font.weight, font.italic, font.stretch)
+    key = (font.name, font.weight, font.style, font.stretch)
     if key in _hb_cache:
         return _hb_cache[key]
 
@@ -79,7 +79,7 @@ def get_resource_from_dw_font(font: Win32DirectWriteFont) -> _HarfbuzzResources:
 
 def get_resource_from_ft_font(font: FreeTypeFont) -> _HarfbuzzResources:
     """Get a harfbuzz resource object from a FreeType (Linux) font."""
-    key = (font.name, font.weight, font.italic, font.stretch)
+    key = (font.name, font.weight, font.style, font.stretch)
     if key in _hb_cache:
         return _hb_cache[key]
 

pyglet/font/pyodide_js.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+import asyncio
+import math
+from asyncio import Task
+from typing import TYPE_CHECKING, ClassVar
+
+import pyglet
+from pyglet.font.ttf import TruetypeInfoBytes
+
+_debug = pyglet.options.debug_font
+
+try:
+    import js
+    import pyodide.ffi
+except ImportError:
+    raise ImportError
+
+from pyglet.font import base, FontManager
+from pyglet.font.base import Glyph, FontException, GlyphPosition
+
+from pyglet.image import ImageData
+
+if TYPE_CHECKING:
+    from pyglet.image import AbstractImage
+
+
+_font_canvas = js.document.createElement("canvas")
+_font_canvas.id = "font_canvas"
+# Added desynchronized for testing. Supposedly lower latency, but may introduce artifacts?
+# Doesn't seem to affect quality since we are just using this to get pixel data. Remove if problem in the future.
+_font_context = _font_canvas.getContext("2d", willReadFrequently=True, desynchronized=True, antialias=False)
+
+class PyodideGlyphRenderer(base.GlyphRenderer):
+    font: JavascriptPyodideFont
+    def __init__(self, font: JavascriptPyodideFont) -> None:  # noqa: D107
+        self.font = font
+        super().__init__(font)
+        self.temp_save = []
+
+    def render(self, text: str) -> Glyph:
+        _font_context.font = self.font.js_name
+        metrics = _font_context.measureText(text)
+        w = max(1, int(math.ceil(metrics.width)))
+        h = max(1, int(math.ceil(metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent)))
+
+        # Setting the canvas size seems to reset the context settings?
+        _font_canvas.width = w
+        _font_canvas.height = h
+        _font_context.imageSmoothingEnabled = False  # Doesn't seem to make a difference with antialiasing?
+        #_font_context.mozImageSmoothingEnabled = False
+        #_font_context.webkitImageSmoothingEnabled = False
+        #_font_context.msImageSmoothingEnabled = False
+        _font_context.font = self.font.js_name
+        _font_context.fillStyle = 'white'
+
+        _font_context.translate(0, h)  # Move down
+        _font_context.scale(1, -1)  # Flip vertically
+
+        # Draw to context
+        _font_context.fillText(text, 0, max(1, int(math.ceil(metrics.actualBoundingBoxAscent))))
+
+        image_data = _font_context.getImageData(0, 0, w, h)
+        pixel_data = image_data.data  # Uint8Array
+
+        image = ImageData(w, h, 'RGBA', pixel_data)
+
+        glyph = self.font.create_glyph(image)
+        glyph.set_bearings(int(math.ceil(metrics.actualBoundingBoxDescent)), 0, w)
+        return glyph
+
+
+def _measure_font_width(font_family: str) -> int:
+    """Use a DOM element to measure the text width of a given string using a font family."""
+    _hidden_div.style.fontSize = "32px"
+    _hidden_div.style.fontFamily = font_family
+    return _hidden_div.offsetWidth
+
+# DIV element used for measuring width for font fallback behavior. Do not remove.
+_hidden_div = js.document.createElement("div")
+_hidden_div.textContent = "PYGLET_FONT_WIDTH"
+_hidden_div.style.visibility  = "hidden"
+_hidden_div.style.position = "absolute"
+_hidden_div.id = "_font_resolver"
+js.document.body.appendChild(_hidden_div)
+
+class JavascriptPyodideFont(base.Font):
+    glyph_renderer_class = PyodideGlyphRenderer
+    _glyph_renderer: PyodideGlyphRenderer
+
+    _default_serif_width = _measure_font_width("serif")
+    _default_sans_serif_width = _measure_font_width("sans-serif")
+
+    # Cache font data by the loaded name dict.
+    _font_data_cache: ClassVar[dict] = {}
+    _name_font_cache: ClassVar[dict] = {}
+
+    def __init__(self, name: str, size: float, weight: str = "normal", style: str = "normal", stretch: str = "normal",
+                 dpi: int | None = None) -> None:
+        self._glyph_renderer = None
+        super().__init__(name, size, weight, style, stretch, dpi)
+
+        if isinstance(weight, str):
+            self._weight = name_to_weight.get(weight.lower(), "normal")
+        else:
+            self._weight = "bold" if weight is True else "normal"
+
+        if isinstance(stretch, str):
+            self._stretch = _name_to_stretch.get(stretch.lower(), "normal")
+        else:
+            self._stretch = "normal"
+
+        self._italic = "italic" if style is True else "normal"
+
+        self.js_name = f"{self._italic} {self._weight} {self.pixel_size}px '{name}'"
+
+        _font_context.font = self.js_name
+        metrics = _font_context.measureText("A")
+        self.ascent = metrics.fontBoundingBoxAscent
+        self.descent = -metrics.fontBoundingBoxDescent
+
+    def get_text_size(self, text: str) -> tuple[int, int]:
+        _font_context.font = self.js_name
+        metrics = _font_context.measureText(text)
+        w = max(1, int(math.ceil(metrics.width)))
+        h = max(1, int(math.ceil(metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent)))
+        return w, h
+
+    @classmethod
+    def add_font_data(cls, data: bytes, manager: FontManager) -> Task:
+        ttf_info = TruetypeInfoBytes(data)
+        family = ttf_info.get_name("family")  # Family Name
+        if family is None:
+            raise FontException("Could not read the font family name.")
+
+        subfamily = ttf_info.get_name("subfamily")  # Contains words like Regular, Bold, etc.
+        if subfamily is None:
+            raise FontException("Could not read the font subfamily name.")
+
+        fullname = ttf_info.get_name("name")  # Usually combines Family + Subfamily, but not always.
+        #if fullname is None:
+        #    raise FontException("Could not read the font name.")
+
+        weight = ttf_info.get_weight_class()  # TTF weight value like 700.
+        clamped_weight = min(max(weight, 100), 900)  # clamp 100-900.
+
+        ttf_stretch_id = ttf_info.get_width_class()
+        italic = "italic" if ttf_info.is_italic() else "normal"
+        js_arr = js.Uint8Array.new(data)
+
+        weight_name = _ttf_weight_to_name.get(clamped_weight, "normal")
+        stretch_name = _width_class_to_pyglet_stretch.get(ttf_stretch_id, "normal")
+
+        # Specify family by the name and the weight.
+        fam_font = js.window.FontFace.new(family, js_arr.buffer,
+                                          weight=str(clamped_weight),
+                                          stretch=_width_class_to_js_stretch.get(ttf_stretch_id, "normal"),
+                                          style=italic,
+                                          )
+
+        if _debug:
+            js.console.log(f"Loaded custom font (family: {family}, subfamily: {subfamily}, full name: {fullname}, "
+                           f"weight: {weight}, stretch_width={ttf_stretch_id})")
+
+
+
+        #if family != fullname:
+            # Full font name may not always match the family name, add both to cover both.
+       #     full_font = js.window.FontFace.new(fullname, js_arr.buffer)
+
+        async def _load_fonts() -> bool:
+            try:
+                await fam_font.load()
+            except Exception as e:  # noqa: BLE001
+                print("Exception occurred loading Family Font:", e)
+                return False
+
+            js.document.fonts.add(fam_font)
+            # js.document.body.style.fontFamily = family
+            # if _debug:
+            #     js.console.log(f"Loaded Family Font: {family}")
+
+            manager._add_loaded_font({(family, weight_name, italic, stretch_name)})  # noqa: SLF001
+
+            # if family != fullname:
+            #     try:
+            #         await full_font.load()
+            #     except Exception as e:
+            #         print("Exception occurred loading Name Font:", e)
+            #         return False
+            #     js.document.fonts.add(full_font)
+            #     if _debug:
+            #         js.console.log(f"Loaded Named Font: {fullname}")
+            #
+            return True
+
+        return asyncio.create_task(_load_fonts())
+
+    def create_glyph(self, img: ImageData) -> Glyph:
+        return super().create_glyph(img)
+
+    def get_glyphs(self, text: str, shaping: bool) -> tuple[list[Glyph], list[GlyphPosition]]:
+        self._initialize_renderer()
+
+        glyphs = []  # glyphs that are committed.
+        offsets = []
+        for c in base.get_grapheme_clusters(str(text)):
+            # Get the glyph for 'c'.  Hide tabs (Windows and Linux render boxes)
+            if c == "\t":
+                c = " "  # noqa: PLW2901
+            if c not in self.glyphs:
+                self.glyphs[c] = self._glyph_renderer.render(c)
+            glyphs.append(self.glyphs[c])
+            offsets.append(GlyphPosition(0, 0, 0, 0))
+        return glyphs, offsets
+
+    def get_glyphs_for_width(self, text: str, width: int) -> list[Glyph]:
+        return super().get_glyphs_for_width(text, width)
+
+    @classmethod
+    def have_font(cls: type[JavascriptPyodideFont], name: str) -> bool:
+        """A very round about way to determine if a font exists for JavaScript.
+
+        JavaScript does not have any way to query system or custom loaded fonts without experimental or
+        unreliable API's. Furthermore, you cannot determine what font is actually being used to render either.
+
+        According to docs, CSS should guarantee the font families of "serif" and "sans-serif".
+
+        Therefore, a hidden element will be used to measure a string to check for a size match between the above
+        font families. If the text matches, then a fallback font was used.
+        """
+        match_serif_name = f"'{name}', serif"
+        match_sans_serif_name = f"'{name}', sans-serif"
+
+        # Check if the font matches our serif.
+        if (_measure_font_width(match_serif_name) == cls._default_serif_width and
+            # Font might actually be the fallback serif, check if it matches a sans serif.
+            _measure_font_width(match_sans_serif_name) == cls._default_sans_serif_width):
+                return False
+
+        # The font should theoretically be available.
+        return True
+
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+# JavaScript/CSS naming, not Pyglet naming.
+_width_class_to_js_stretch = {
+    1: "ultra-condensed",
+    2: "extra-condensed",
+    3: "condensed",
+    4: "semi-condensed",
+    5: "normal",
+    6: "semi-expanded",
+    7: "expanded",
+    8: "extra-expanded",
+    9: "ultra-expanded",
+}
+
+_width_class_to_pyglet_stretch = {
+    1: "ultracondensed",
+    2: "extracondensed",
+    3: "condensed",
+    4: "semicondensed",
+    5: "normal",
+    6: "semiexpanded",
+    7: "expanded",
+    8: "extraexpanded",
+    9: "ultraexpanded",
+}
+
+name_to_weight = {
+    'thin': 100,
+    'extralight': 200,
+    'light': 300,
+    'normal': 400,
+    'medium': 500,
+    'semibold': 600,
+    'bold': 700,
+    'extrabold': 800,
+    'black': 900,
+}
+_ttf_weight_to_name = {
+    100: 'thin',
+    200: 'extralight',
+    300: 'light',
+    400: 'normal',
+    500: 'medium',
+    600: 'semibold',
+    700: 'bold',
+    800: 'extrabold',
+    900: 'black',
+}
+
+_name_to_stretch = {
+    "undefined": "normal",
+    "ultracondensed": "ultra-condensed",
+    "extracondensed": "extra-condensed",
+    "condensed": "condensed",
+    "semicondensed": "semi-condensed",
+    "normal": "normal",
+    "medium": "normal",
+    "semiexpanded": "semi-expanded",
+    "expanded": "expanded",
+    "extraexpanded": "extra-expanded",
+    "narrow": "condensed",
+    "ultraexpanded": "ultra-expanded",
+}