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

pyglet/font/ttf.py

@@ -14,8 +14,11 @@ import codecs
 import mmap
 import os
 import struct
+from io import BytesIO
 from typing import Any
 
+from pyglet.font.base import FontException
+
 
 class TruetypeInfo:
     """Information about a single Truetype face.
@@ -94,6 +97,9 @@ class TruetypeInfo:
 
         self._closed = False
 
+        self._read_tables()
+
+    def _read_tables(self) -> None:
         offsets = _read_offset_table(self._data, 0)
         self._tables = {}
         for table in _read_table_directory_entry.array(self._data, offsets.size, offsets.num_tables):
@@ -107,6 +113,8 @@ class TruetypeInfo:
         self._character_map = None
         self._glyph_map = None
         self._font_selection_flags = None
+        self._weight_class = None
+        self._width_class = None
 
         self.header = _read_head_table(self._data, self._tables["head"].offset)
         self.horizontal_header = _read_horizontal_header(self._data, self._tables["hhea"].offset)
@@ -118,6 +126,18 @@ class TruetypeInfo:
             self._font_selection_flags = OS2_table.fs_selection
         return self._font_selection_flags
 
+    def get_weight_class(self) -> int:
+        if not self._weight_class:
+            OS2_table = _read_OS2_table(self._data, self._tables["OS/2"].offset)
+            self._weight_class = OS2_table.us_weight_class
+        return self._weight_class
+
+    def get_width_class(self) -> int:
+        if not self._width_class:
+            OS2_table = _read_OS2_table(self._data, self._tables["OS/2"].offset)
+            self._width_class = OS2_table.us_width_class
+        return self._width_class
+
     def is_bold(self) -> bool:
         """Returns True iff the font describes itself as bold."""
         return bool(self.get_font_selection_flags() & 0x20)
@@ -126,15 +146,14 @@ class TruetypeInfo:
         """Returns True iff the font describes itself as italic."""
         return bool(self.get_font_selection_flags() & 0x1)
 
-    def get_names(self) -> dict[tuple[int, int], tuple[int, int, str]]:
+    def get_names(self) -> dict[tuple[int, int], tuple[int, int, bytes]]:
         """Returns a dictionary of names defined in the file.
 
         The key of each item is a tuple of ``platform_id``, ``name_id``,
         where each ID is the number as described in the Truetype format.
 
         The value of each item is a tuple of
-        ``encoding_id``, ``language_id``, ``value``, where ``value`` is
-        an encoded string.
+        ``encoding_id``, ``language_id``, ``value``, where ``value`` is an encoded string.
         """
         if self._names:
             return self._names
@@ -415,6 +434,29 @@ class TruetypeInfo:
         if not self._closed:
             self.close()
 
+class TruetypeInfoBytes(TruetypeInfo):
+    """A subclass of TruetypeInfo that uses bytes, not mmap as mmap is not supported in Emscripten."""
+
+    def __init__(self, data: bytes) -> None:  # noqa, noqa: RUF100
+        """Read the given TrueType file.
+
+        Args:
+            data:
+                Bytes data containing a font file.
+
+        An exception will be raised if the data cannot be read.
+        """
+        self._closed = False
+        self._data = data
+
+        try:
+            self._read_tables()
+        except Exception as err:
+            msg = "Failed to read the font tables. Ensure this data contains a TrueType or OpenType Font."
+            raise FontException(msg) from err
+
+    def close(self) -> None:
+        self._closed = True
 
 def _read_table(*entries: str):
     """ Generic table constructor used for table formats listed at

pyglet/font/user.py

@@ -85,7 +85,7 @@ class UserDefinedGlyphRenderer(base.GlyphRenderer):
     def render(self, image_data: ImageData) -> Glyph:
         if self._font._scaling:  # noqa: SLF001
             image_original = Image.frombytes("RGBA", (image_data.width, image_data.height),
-                                             image_data.get_image_data().get_data("RGBA"))
+                                             image_data.get_image_data().get_bytes("RGBA"))
             scale_ratio = self._font.size / self._font._base_size
             image_resized = image_original.resize((int(image_data.width * scale_ratio),
                                                    int(image_data.height * scale_ratio)), Resampling.NEAREST)
@@ -108,7 +108,7 @@ class UserDefinedFontBase(base.Font):
 
     def __init__(
             self, name: str, default_char: str, size: int, ascent: int | None = None, descent: int | None = None,
-            weight: str = "normal", italic: bool = False, stretch: bool = False, dpi: int = 96, locale: str | None = None,
+            weight: str = "normal", style: str = "normal", stretch: str = "normal", dpi: int = 96, locale: str | None = None,
     ) -> None:
         """Initialize a user defined font.
 
@@ -126,7 +126,7 @@ class UserDefinedFontBase(base.Font):
                 Maximum descent below the baseline, in pixels. Usually negative.
             weight:
                 The font weight, as a string. Defaults to "normal".
-            italic:
+            style:
                 If True, this font will be used when ``italic`` is enabled for the font name.
             stretch:
                 If True, this font will be used when ``stretch`` is enabled for the font name.
@@ -136,16 +136,10 @@ class UserDefinedFontBase(base.Font):
             locale:
                 Used to specify the locale of this font.
         """
-        super().__init__()
-        self._name = name
+        super().__init__(name, size, weight, style, stretch, dpi)
         self.default_char = default_char
         self.ascent = ascent
         self.descent = descent
-        self.size = size
-        self.weight = weight
-        self.italic = italic
-        self.stretch = stretch
-        self.dpi = dpi
         self.locale = locale
 
         self._base_size = 0
@@ -188,8 +182,9 @@ class UserDefinedMappingFont(UserDefinedFontBase):
     _glyph_renderer: UserDefinedGlyphRenderer
 
     def __init__(self, name: str, default_char: str, size: int, mappings: DictLikeObject,
-            ascent: int | None = None, descent: int | None = None, weight: str = "normal", italic: bool = False,
-            stretch: bool = False, dpi: int = 96, locale: str | None = None) -> None:
+            ascent: int | None = None, descent: int | None = None,
+            weight: str = "normal", style: str = "normal", stretch: str = "normal",
+            dpi: int = 96, locale: str | None = None) -> None:
         """Initialize the default parameters of your font.
 
         Args:
@@ -209,10 +204,10 @@ class UserDefinedMappingFont(UserDefinedFontBase):
                 Maximum descent below the baseline, in pixels. Usually negative.
             weight:
                 The font weight, as a string. Defaults to "normal".
-            italic:
-                If ``True``, this font will be used when ``italic`` is enabled for the font name.
+            style:
+                The font style, as a string. Defaults to "normal".
             stretch:
-                If ``True``, this font will be used when ``stretch`` is enabled for the font name.
+                The font stretch, as a string. Defaults to "normal".
             dpi:
                 The assumed resolution of the display device, for the purposes of determining the pixel size of the
                 font. Use a default of 96 for standard sizing.
@@ -231,7 +226,7 @@ class UserDefinedMappingFont(UserDefinedFontBase):
             if descent is None:
                 descent = 0
 
-        super().__init__(name, default_char, size, ascent, descent, weight, italic, stretch, dpi, locale)
+        super().__init__(name, default_char, size, ascent, descent, weight, style, stretch, dpi, locale)
 
     def enable_scaling(self, base_size: int) -> None:
         """Enables scaling the font size.
@@ -241,11 +236,11 @@ class UserDefinedMappingFont(UserDefinedFontBase):
                 The base size is used to calculate the ratio between new sizes and the original.
         """
         super().enable_scaling(base_size)
-        glyphs, offsets = self.get_glyphs(self.default_char)
+        glyphs, offsets = self.get_glyphs(self.default_char, False)
         self.ascent = glyphs[0].height
         self.descent = 0
 
-    def get_glyphs(self, text: str) -> tuple[list[Glyph], list[GlyphPosition]]:
+    def get_glyphs(self, text: str, shaping: bool = False) -> 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 font, a substitution will be made with
@@ -284,7 +279,7 @@ def get_scaled_user_font(font_base: UserDefinedMappingFont, size: int) -> UserDe
             The new font size. This will be scaled based on the ratio between the base size and the new size.
     """
     new_font = UserDefinedMappingFont(font_base.name, font_base.default_char, size, font_base.mappings,
-                                      font_base.ascent, font_base.descent, font_base.weight, font_base.italic,
+                                      font_base.ascent, font_base.descent, font_base.weight, font_base.style,
                                       font_base.stretch, font_base.dpi, font_base.locale)
 
     new_font.enable_scaling(font_base.size)

pyglet/font/win32.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, ClassVar, Sequence
 
 import pyglet
 import pyglet.image
-from pyglet.font import base
+from pyglet.font import base, FontManager
 from pyglet.image.codecs.gdiplus import BitmapData, ImageLockModeRead, PixelFormat32bppARGB, Rect, gdiplus
 from pyglet.libs.win32 import _gdi32 as gdi32
 from pyglet.libs.win32 import _user32 as user32
@@ -20,6 +20,7 @@ if TYPE_CHECKING:
     from pyglet.font.base import Glyph
 
 
+
 DriverStringOptionsCmapLookup = 1
 DriverStringOptionsRealizedAdvance = 4
 TextRenderingHintSingleBitPerPixelGridFit = 1
@@ -45,7 +46,7 @@ StringFormatFlagsNoClip = 0x00004000
 FontFamilyNotFound = 14
 
 
-_debug_font = pyglet.options["debug_font"]
+_debug_font = pyglet.options.debug_font
 
 
 class Rectf(ctypes.Structure):
@@ -221,7 +222,7 @@ class GDIPlusGlyphRenderer(base.GlyphRenderer):
             # This hack bumps up the width if the font is italic;
             # this compensates for some common fonts.  It's also a stupid
             # waste of texture memory.
-            if self.font.italic:
+            if self.font.style:
                 width += width // 2
                 # Do not enlarge more than the _rect width.
                 width = min(width, self._rect.Width)
@@ -270,12 +271,15 @@ class Win32Font(base.Font):
     def __init__(
             self,
             name: str, size: float,
-            weight: str = "normal", italic: bool = False, stretch: bool = False,
+            weight: str = "normal",
+            style: str = "normal",
+            stretch: str = "normal",
             dpi: int | None = None,
     ) -> None:
-        super().__init__()
+        super().__init__(name, size, weight, style, stretch, dpi)
 
-        bold = weight if weight in (None, True, False) else "bold" in weight
+        bold = weight != "normal"
+        italic = style != "normal"
 
         self.logfont = self.get_logfont(name, size, bold, italic, dpi)
         self.hfont = gdi32.CreateFontIndirectW(ctypes.byref(self.logfont))
@@ -341,6 +345,15 @@ def _get_font_families(font_collection: ctypes.c_void_p) -> Sequence[ctypes.c_vo
 
     return gpfamilies
 
+def _get_font_family_names(font_collection: ctypes.c_void_p) -> set[str]:
+    names = set()
+    font_name = ctypes.create_unicode_buffer(32)
+    for gpfamily in _get_font_families(font_collection):
+        gdiplus.GdipGetFamilyName(gpfamily, font_name, "\0")
+        names.add(font_name.value)
+
+    return names
+
 def _font_exists_in_collection(font_collection: ctypes.c_void_p, name: str) -> bool:
     font_name = ctypes.create_unicode_buffer(32)
     for gpfamily in _get_font_families(font_collection):
@@ -359,17 +372,15 @@ class GDIPlusFont(Win32Font):
 
     _default_name = "Arial"
 
-    def __init__(self, name: str, size: float, weight: str = "normal", italic: bool=False, stretch: bool=False,
+    def __init__(self, name: str, size: float, weight: str = "normal", style: str = "normal", stretch: str= "normal",
                  dpi: int | None=None) -> None:
         if not name:
             name = self._default_name
 
-        if stretch:
-            warnings.warn("The current font render does not support stretching.")  # noqa: B028
-
-        bold = weight if weight in (None, True, False) else "bold" in weight
+        if stretch != "normal":
+            warnings.warn("The current font render does not support the stretch argument.")
 
-        super().__init__(name, size, bold, italic, stretch, dpi)
+        super().__init__(name, size, weight, style, stretch, dpi)
 
         self._name = name
 
@@ -406,13 +417,13 @@ class GDIPlusFont(Win32Font):
             size = (size * dpi) // 72
             self.dpi = dpi
 
-        style = 0
-        if bold:
-            style |= FontStyleBold
-        if italic:
-            style |= FontStyleItalic
+        gdip_style = 0
+        if weight != "normal":
+            gdip_style |= FontStyleBold
+        if style != "normal":
+            gdip_style |= FontStyleItalic
         self._gdipfont = ctypes.c_void_p()
-        gdiplus.GdipCreateFont(family, ctypes.c_float(size), style, unit, ctypes.byref(self._gdipfont))
+        gdiplus.GdipCreateFont(family, ctypes.c_float(size), gdip_style, unit, ctypes.byref(self._gdipfont))
         gdiplus.GdipDeleteFontFamily(family)
 
     @property
@@ -424,7 +435,7 @@ class GDIPlusFont(Win32Font):
         gdiplus.GdipDeleteFont(self._gdipfont)
 
     @classmethod
-    def add_font_data(cls: type[GDIPlusFont], data: bytes) -> None:
+    def add_font_data(cls: type[GDIPlusFont], data: bytes, manager: FontManager) -> None:
         numfonts = ctypes.c_uint32()
         _handle = gdi32.AddFontMemResourceEx(data, len(data), 0, ctypes.byref(numfonts))
 
@@ -433,11 +444,24 @@ class GDIPlusFont(Win32Font):
             raise ctypes.WinError()
 
         if not cls._private_collection:
+            _loaded_families = set()
             cls._private_collection = ctypes.c_void_p()
-            gdiplus.GdipNewPrivateFontCollection(
-                ctypes.byref(cls._private_collection))
+            gdiplus.GdipNewPrivateFontCollection(ctypes.byref(cls._private_collection))
+        else:
+            _loaded_families = _get_font_family_names(cls._private_collection)
+
         gdiplus.GdipPrivateAddMemoryFont(cls._private_collection, data, len(data))
 
+        current_families = _get_font_family_names(cls._private_collection)
+
+        new_font = current_families - _loaded_families
+        if len(new_font) > 0:
+            font_name = list(new_font)[0]
+            manager._add_loaded_font({(font_name, "normal", "normal", "normal")})
+
+        # Loaded a variant?
+
+
     @classmethod
     def have_font(cls: type[GDIPlusFont], name: str) -> bool:
         # Enumerate the private collection fonts first, as those are most likely to be used.