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

pyglet/font/dwrite/dwrite_lib.py

@@ -168,6 +168,28 @@ DWRITE_FONT_FACE_TYPE_UNKNOWN = 6
 DWRITE_FONT_FACE_TYPE_RAW_CFF = 7
 DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION = 8
 
+DWRITE_FONT_PROPERTY_ID = UINT
+DWRITE_FONT_PROPERTY_ID_NONE = 0
+DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FAMILY_NAME = 1
+DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FAMILY_NAME = 2
+DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FACE_NAME = 3
+DWRITE_FONT_PROPERTY_ID_FULL_NAME = 4
+DWRITE_FONT_PROPERTY_ID_WIN32_FAMILY_NAME = 5
+DWRITE_FONT_PROPERTY_ID_POSTSCRIPT_NAME = 6
+DWRITE_FONT_PROPERTY_ID_DESIGN_SCRIPT_LANGUAGE_TAG = 7
+DWRITE_FONT_PROPERTY_ID_SUPPORTED_SCRIPT_LANGUAGE_TAG = 8
+DWRITE_FONT_PROPERTY_ID_SEMANTIC_TAG = 9
+DWRITE_FONT_PROPERTY_ID_WEIGHT = 10
+DWRITE_FONT_PROPERTY_ID_STRETCH = 11
+DWRITE_FONT_PROPERTY_ID_STYLE = 12
+DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME = 13
+DWRITE_FONT_PROPERTY_ID_TOTAL = 14
+DWRITE_FONT_PROPERTY_ID_TOTAL_RS3 = 15
+DWRITE_FONT_PROPERTY_ID_PREFERRED_FAMILY_NAME = 16
+DWRITE_FONT_PROPERTY_ID_FAMILY_NAME = 17
+DWRITE_FONT_PROPERTY_ID_FACE_NAME = 18
+
+
 def repr_func(self):
     field_values = []
     for field_value in self._fields_:
@@ -368,7 +390,7 @@ class IDWriteFontFace(com.pIUnknown):
         ("GetIndex",
          com.METHOD(UINT32)),
         ("GetSimulations",
-         com.STDMETHOD()),
+         com.METHOD(UINT32)),
         ("IsSymbolFont",
          com.METHOD(BOOL)),
         ("GetMetrics",
@@ -682,7 +704,7 @@ class IDWriteFont(com.pIUnknown):
         ("GetInformationalStrings",
          com.STDMETHOD(DWRITE_INFORMATIONAL_STRING_ID, POINTER(IDWriteLocalizedStrings), POINTER(BOOL))),
         ("GetSimulations",
-         com.STDMETHOD()),
+         com.METHOD(UINT32)),
         ("GetMetrics",
          com.STDMETHOD()),
         ("HasCharacter",
@@ -1155,11 +1177,11 @@ class IDWriteFontSet(com.pIUnknown):
         ("FindFontFace",
          com.STDMETHOD()),
         ("GetPropertyValues__",
-         com.STDMETHOD()),
+         com.STDMETHOD(UINT32, DWRITE_FONT_PROPERTY_ID, POINTER(BOOL), POINTER(IDWriteLocalizedStrings))),
         ("GetPropertyValues_",
-         com.STDMETHOD()),
+         com.STDMETHOD(DWRITE_FONT_PROPERTY_ID, c_wchar_p, c_void_p)),
         ("GetPropertyValues",
-         com.STDMETHOD()),
+         com.STDMETHOD(DWRITE_FONT_PROPERTY_ID, c_void_p)),
         ("GetPropertyOccurrenceCount",
          com.STDMETHOD()),
         ("GetMatchingFonts_",

pyglet/font/fontconfig.py

@@ -5,6 +5,7 @@ from collections import OrderedDict
 from ctypes import CDLL, Structure, Union, byref, c_char_p, c_double, c_int, c_uint, c_void_p, POINTER
 from typing import TYPE_CHECKING
 
+from pyglet.enums import Style
 from pyglet.font.base import FontException
 from pyglet.lib import load_library
 from pyglet.util import asbytes, asstr
@@ -200,7 +201,9 @@ class FontConfig:
         return result.weight, result.italic, result.stretch
 
     def find_font(self, name: str, size: float = 12, weight: str = "normal",
-                  italic: bool = False, stretch: str = "normal") -> FontConfigSearchResult:
+                  italic: str = "normal", stretch: str = "normal") -> FontConfigSearchResult:
+        assert isinstance(weight, str)
+        assert isinstance(italic, str)
         if result := self._get_from_search_cache(name, size, weight, italic, stretch):
             return result
 
@@ -239,7 +242,7 @@ class FontConfig:
             self._search_cache.popitem(last=False)[1].dispose()
 
     def _get_from_search_cache(self, name: str, size: float, weight: str,
-                               italic: bool, stretch: str) -> FontConfigSearchResult | None:
+                               italic: str, stretch: str) -> FontConfigSearchResult | None:
         result = self._search_cache.get((name, size, weight, italic, stretch), None)
 
         if result and result.is_valid:
@@ -295,8 +298,13 @@ class FontConfigPattern:
         self._pattern = None
 
     @staticmethod
-    def _italic_to_slant(italic: bool) -> int:
-        return FC_SLANT_ITALIC if italic else FC_SLANT_ROMAN
+    def _italic_to_slant(italic: str) -> int:
+        if italic == Style.ITALIC:
+            return FC_SLANT_ITALIC
+        if italic == Style.OBLIQUE:
+            return FC_SLANT_OBLIQUE
+
+        return FC_SLANT_ROMAN
 
     def _set_string(self, name: bytes, value: str) -> None:
         assert self._pattern
@@ -377,7 +385,7 @@ class FontConfigPattern:
 
 class FontConfigSearchPattern(FontConfigPattern):
     size: float | None
-    italic: bool
+    italic: str
     weight: str
     name: str | None
     stretch: str
@@ -387,7 +395,7 @@ class FontConfigSearchPattern(FontConfigPattern):
 
         self.name = None
         self.weight = "normal"
-        self.italic = False
+        self.italic = "normal"
         self.size = None
         self.stretch = 'normal'
 

pyglet/font/freetype.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import warnings
-from ctypes import POINTER, byref, c_ubyte, cast, memmove
-from typing import NamedTuple, Sequence
+from ctypes import POINTER, byref, c_ubyte, cast, memmove, string_at, Array
+from typing import NamedTuple, Sequence, TYPE_CHECKING
 
 import pyglet
 from pyglet import image
@@ -26,13 +26,31 @@ from pyglet.font.freetype_lib import (
     FT_Set_Char_Size,
     f26p6_to_float,
     float_to_f26p6,
-    ft_get_library, FT_LOAD_TARGET_MONO, FT_LOAD_COLOR, FT_FACE_FLAG_SCALABLE, FT_FACE_FLAG_FIXED_SIZES,
-    FT_FACE_FLAG_COLOR, FT_Select_Size, FT_PIXEL_MODE_BGRA, FT_Get_Char_Index, FT_FACE_FLAG_KERNING, FT_Vector,
-    FT_Get_Kerning, FT_KERNING_DEFAULT, FT_LOAD_NO_BITMAP, FT_Load_Char
+    ft_get_library,
+    FT_LOAD_TARGET_MONO,
+    FT_LOAD_COLOR,
+    FT_FACE_FLAG_SCALABLE,
+    FT_FACE_FLAG_FIXED_SIZES,
+    FT_FACE_FLAG_COLOR,
+    FT_Select_Size,
+    FT_PIXEL_MODE_BGRA,
+    FT_Get_Char_Index,
+    FT_LOAD_NO_BITMAP,
+    FT_Load_Char,
+    FT_FACE_FLAG_SFNT,
+    FT_SfntName,
+    FT_Get_Sfnt_Name_Count,
+    FT_Get_Sfnt_Name,
+    TT_NAME_ID_FULL_NAME,
+    TT_NAME_ID_FONT_FAMILY,
 )
 from pyglet.font.harfbuzz import harfbuzz_available, get_resource_from_ft_font, get_harfbuzz_shaped_glyphs
-from pyglet.util import asbytes, asstr
+from pyglet.util import asbytes, asstr, debug_print
 
+_debug_font = debug_print("debug_font")
+
+if TYPE_CHECKING:
+    from pyglet.font import FontManager
 
 class FreeTypeGlyphRenderer(base.GlyphRenderer):
     def __init__(self, font: FreeTypeFont) -> None:
@@ -70,7 +88,12 @@ class FreeTypeGlyphRenderer(base.GlyphRenderer):
         self._mode = self._glyph_slot.bitmap.pixel_mode
         self._pitch = self._glyph_slot.bitmap.pitch
 
-        self._baseline = self._height - self._glyph_slot.bitmap_top
+        # Hack! Adjust baseline position depending backends for now.
+        if pyglet.options.backend == "vulkan":
+            self._baseline = self._glyph_slot.bitmap_top - self.font.descent - self.font.ascent
+        else:
+            self._baseline = self._height - self._glyph_slot.bitmap_top
+
         self._lsb = self._glyph_slot.bitmap_left
         self._advance_x = int(f26p6_to_float(self._glyph_slot.advance.x))
 
@@ -137,6 +160,34 @@ class FreeTypeGlyphRenderer(base.GlyphRenderer):
         self._data = data
         self._pitch = self._width
 
+    def _expand_to_rgba(self, data: bytes, src_format: str, dst_format: str) -> bytes:
+        """Expands data type to RGBA with putting values into A.
+
+        Will re-evaluate on a better system later.
+        """
+        src_len = len(src_format)
+        dst_len = len(dst_format)
+
+        if src_len >= dst_len:
+            return data
+
+        expanded_data = bytearray(len(data) // src_len * dst_len)
+        mapping = {c: i for i, c in enumerate(src_format)}
+
+        for i in range(len(data) // src_len):
+            default_value = data[i * src_len + 0] if src_len > 0 else 0
+
+            for j, c in enumerate(dst_format):
+                if c in mapping:
+                    expanded_data[i * dst_len + j] = 255
+                elif c == 'A':
+                    # Default alpha to fully opaque
+                    expanded_data[i * dst_len + j] = default_value
+                else:
+                    expanded_data[i * dst_len + j] = 255
+
+        return bytes(expanded_data)
+
     def _create_glyph(self) -> base.Glyph:
         # Textures should be a minimum of 1x1.
         if self._width == 0 and self._height == 0:
@@ -190,21 +241,22 @@ class FreeTypeFontMetrics(NamedTuple):
 
 
 class MemoryFaceStore:
-    _dict: dict[tuple[str, str, bool], FreeTypeMemoryFace]
+    _dict: dict[tuple[str, str, str, str], FreeTypeMemoryFace]
 
     def __init__(self) -> None:
         self._dict = {}
 
     def add(self, face: FreeTypeMemoryFace) -> None:
-        self._dict[face.name.lower(), face.weight, face.italic] = face
+        self._dict[face.name, face.weight, face.style, face.stretch] = face
 
     def contains(self, name: str) -> bool:
-        lname = name and name.lower() or ""
-        return len([name for name, _, _ in self._dict if name == lname]) > 0
+        return len([fn_name for fn_name, _, _, _ in self._dict if name.lower() == fn_name.lower()]) > 0
+
+    def get(self, name: str, weight: str, style: str, stretch: str) -> FreeTypeMemoryFace | None:
+        return self._dict.get((name, weight, style, stretch), None)
 
-    def get(self, name: str, weight: str, italic: bool) -> FreeTypeMemoryFace | None:
-        lname = name and name.lower() or ""
-        return self._dict.get((lname, weight, italic), None)
+    def all_keys(self) -> list[tuple[str, str, str, str]]:
+        return list(self._dict.keys())
 
 
 class FreeTypeFont(base.Font):
@@ -214,18 +266,12 @@ class FreeTypeFont(base.Font):
     # Map font (name, weight, italic) to FreeTypeMemoryFace
     _memory_faces = MemoryFaceStore()
     face: FreeTypeFace
-    fallbacks: list[FreeTypeFont]
-
-    def __init__(self, name: str, size: float, weight: str = "normal", italic: bool = False,
-                 stretch: bool | str = False, dpi: int | None = None) -> None:
-        super().__init__()
-        self._name = name
-        self.size = size
-        self.weight = weight
-        self.italic = italic
-        self.stretch = stretch
-        self.dpi = dpi or 96
-        self.pixel_size = (self.size * self.dpi) // 72
+
+    def __init__(self, name: str, size: float,
+                 weight: str = "normal",
+                 style: str = "normal",
+                 stretch: str = "normal", dpi: int | None = None) -> None:
+        super().__init__(name, size, weight, style, stretch, dpi)
 
         self._load_font_face()
         self.metrics = self.face.get_font_metrics(self.size, self.dpi)
@@ -245,42 +291,22 @@ class FreeTypeFont(base.Font):
     def descent(self) -> int:
         return self.metrics.descent
 
-    def add_fallback(self, font):
-        self.fallbacks.append(font)
-
-    def _get_slot_from_fallbacks(self, character: str) -> FT_GlyphSlot | None:
-        """Checks all fallback fonts in order to find a valid glyph index."""
-        # Check if fallback has this glyph, if so.
-        for fallback_font in self.fallbacks:
-            fb_index = fallback_font.face.get_character_index(character)
-            if fb_index:
-                fallback_font.face.set_char_size(self.size, self.dpi)
-                return fallback_font.get_glyph_slot(character)
-
-        return None
-
     def get_glyph_slot_index(self, glyph_index: int) -> FT_GlyphSlot:
         self.face.set_char_size(self.size, self.dpi)
         return self.face.get_glyph_slot(glyph_index)
 
     def get_glyph_slot(self, character: str) -> FT_GlyphSlot:
         glyph_index = self.face.get_character_index(character)
-        # Glyph index does not exist, so check fallback fonts.
-        if glyph_index == 0 and (self.name not in self.fallbacks):
-            glyph_slot = self._get_slot_from_fallbacks(character)
-            if glyph_slot is not None:
-                return glyph_slot
-
         self.face.set_char_size(self.size, self.dpi)
         return self.face.get_glyph_slot(glyph_index)
 
     def _load_font_face(self) -> None:
-        self.face = self._memory_faces.get(self._name, self.weight, self.italic)
+        self.face = self._memory_faces.get(self._name, self.weight, self.style, self.stretch)
         if self.face is None:
             self._load_font_face_from_system()
 
     def _load_font_face_from_system(self) -> None:
-        match = get_fontconfig().find_font(self._name, self.size, self.weight, self.italic, self.stretch)
+        match = get_fontconfig().find_font(self._name, self.size, self.weight, self.style, self.stretch)
         if not match:
             msg = f"Could not match font '{self._name}'"
             raise base.FontException(msg)
@@ -295,7 +321,7 @@ class FreeTypeFont(base.Font):
         return get_fontconfig().have_font(name)
 
     @classmethod
-    def add_font_data(cls: type[FreeTypeFont], data: bytes) -> None:
+    def add_font_data(cls: type[FreeTypeFont], data: bytes, manager: FontManager) -> None:
         font_data = (FT_Byte * len(data))()
         memmove(font_data, data, len(data))
 
@@ -308,7 +334,10 @@ class FreeTypeFont(base.Font):
                 face = FreeTypeMemoryFace(font_data, i)
                 cls._memory_faces.add(face)
 
-    def render_glyph_indices(self, indices: Sequence[int]):
+        all_fonts = cls._memory_faces.all_keys()
+        manager._add_loaded_font(set(all_fonts))  # noqa: SLF001
+
+    def render_glyph_indices(self, indices: Sequence[int]) -> None:
         # Process any glyphs that have not been rendered.
         self._initialize_renderer()
 
@@ -321,7 +350,7 @@ class FreeTypeFont(base.Font):
         for glyph_indice in missing:
             self.glyphs[glyph_indice] = self._glyph_renderer.render_index(glyph_indice)
 
-    def get_glyphs(self, text: str) -> tuple[list[base.Glyph], list[base.GlyphPosition]]:
+    def get_glyphs(self, text: str, shaping: bool) -> tuple[list[base.Glyph], list[base.GlyphPosition]]:
         """Create and return a list of Glyphs for `text`.
 
         If any characters do not have a known glyph representation in this
@@ -330,22 +359,24 @@ class FreeTypeFont(base.Font):
         Args:
             text:
                 Text to render.
+            shaping:
+                If the text will be shaped using the global option.
         """
         self._initialize_renderer()
-        if pyglet.options.text_shaping == "harfbuzz" and harfbuzz_available():
+
+        if shaping and pyglet.options.text_shaping == "harfbuzz" and harfbuzz_available():
             return get_harfbuzz_shaped_glyphs(self, text)
-        else:
-            glyphs = []  # glyphs that are committed.
-            for idx, c in enumerate(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])
-
-            return glyphs, [GlyphPosition(0, 0, 0, 0)] * len(text)
+
+        glyphs = []  # glyphs that are committed.
+        for idx, c in enumerate(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])
+
+        return glyphs, [GlyphPosition(0, 0, 0, 0)] * len(text)
 
     def get_text_size(self, text: str) -> tuple[int, int]:
         width = 0
@@ -387,9 +418,11 @@ class FreeTypeFace:
         self._get_best_name()
 
         self._italic = self.style_flags & FT_STYLE_FLAG_ITALIC != 0
+        self._style = "italic" if self._italic else "normal"
         bold = self.style_flags & FT_STYLE_FLAG_BOLD != 0
         if bold:
             self._weight = "bold"
+            self._stretch = "normal"
         else:
             # Sometimes it may have a weight, but FT_STYLE_FLAG_BOLD is not accurate. Check the font config.
             config = get_fontconfig()
@@ -413,11 +446,11 @@ class FreeTypeFace:
         if match.face is not None:
             FT_Reference_Face(match.face)
             return cls(match.face)
-        else:
-            if not match.file:
-                msg = f'No filename for "{match.name}"'
-                raise base.FontException(msg)
-            return cls.from_file(match.file)
+
+        if not match.file:
+            msg = f'No filename for "{match.name}"'
+            raise base.FontException(msg)
+        return cls.from_file(match.file)
 
     @property
     def name(self) -> str:
@@ -447,6 +480,14 @@ class FreeTypeFace:
     def italic(self) -> bool:
         return self._italic
 
+    @property
+    def stretch(self) -> str:
+        return self._stretch
+
+    @property
+    def style(self) -> str:
+        return self._style
+
     @property
     def face_flags(self) -> int:
         return self.ft_face.contents.face_flags
@@ -514,36 +555,46 @@ class FreeTypeFace:
         i = self.get_character_index("X")
         self.get_glyph_slot(i)
         ascent = self.ft_face.contents.available_sizes.contents.height
-        return FreeTypeFontMetrics(ascent=ascent,
-                                   descent=-ascent // 4)  # arbitrary.
+        return FreeTypeFontMetrics(ascent=ascent, descent=-ascent // 4)  # arbitrary.
 
     def _get_best_name(self) -> None:
         self._name = asstr(self.ft_face.contents.family_name)
-        self._get_font_family_from_ttf()
 
-    def _get_font_family_from_ttf(self) -> None:
         # Replace Freetype's generic family name with TTF/OpenType specific
         # name if we can find one; there are some instances where Freetype
         # gets it wrong.
+        if (ttf_name := self._get_ttf_string(TT_NAME_ID_FONT_FAMILY)) and ttf_name != self._name:
+            assert _debug_font(f"FreeType name: {self._name} does not match header name: {ttf_name}")
 
-        return  # FIXME: This is broken
-
+    def _get_ttf_string(self, name_id: int) -> str | None:
+        """Return the value from the TTF/OTF/AAT font table for the specified TT_NAME_ID."""
         if self.face_flags & FT_FACE_FLAG_SFNT:
-            name = FT_SfntName()
-            for i in range(FT_Get_Sfnt_Name_Count(self.ft_face)):
-                try:
-                    FT_Get_Sfnt_Name(self.ft_face, i, name)
-                    if not (name.platform_id == TT_PLATFORM_MICROSOFT and
-                            name.encoding_id == TT_MS_ID_UNICODE_CS):
-                        continue
-                    # name.string is not 0 terminated! use name.string_len
-                    self._name = name.string.decode("utf-16be", "ignore")
-                except:
-                    continue
+            name_count = FT_Get_Sfnt_Name_Count(self.ft_face)
+            for i in range(name_count):
+                name = FT_SfntName()
+                FT_Get_Sfnt_Name(self.ft_face, i, name)
+                if name.platform_id == name_id:
+                    raw = string_at(name.string, name.string_len)
+
+                    # First try decoding with UTF-16BE (used by Windows name table)
+                    try:
+                        full_name = raw.decode("utf-16-be")
+                    except UnicodeDecodeError:
+                        full_name = raw.decode("latin1", errors="replace")
+
+                    return full_name
+
+        return None
+
+    def _get_full_name(self) -> str | None:
+        """Checks the font naming table."""
+        return self._get_ttf_string(TT_NAME_ID_FULL_NAME)
+
+
 
 
 class FreeTypeMemoryFace(FreeTypeFace):
-    def __init__(self, data: bytes, face_index: int = 0) -> None:
+    def __init__(self, data: Array, face_index: int = 0) -> None:
         self.font_data = data
         ft_library = ft_get_library()
         ft_face = FT_Face()

pyglet/font/freetype_lib.py

@@ -672,7 +672,9 @@ FT_Get_Sfnt_Name = _get_function_with_error_handling("FT_Get_Sfnt_Name",
                                                      [FT_Face, FT_UInt, POINTER(FT_SfntName)], FT_Error)
 
 TT_PLATFORM_MICROSOFT = 3
+
 TT_MS_ID_UNICODE_CS = 1
+
 TT_NAME_ID_COPYRIGHT = 0
 TT_NAME_ID_FONT_FAMILY = 1
 TT_NAME_ID_FONT_SUBFAMILY = 2
@@ -681,6 +683,8 @@ TT_NAME_ID_FULL_NAME = 4
 TT_NAME_ID_VERSION_STRING = 5
 TT_NAME_ID_PS_NAME = 6
 TT_NAME_ID_TRADEMARK = 7
+
+# From OpenType:
 TT_NAME_ID_MANUFACTURER = 8
 TT_NAME_ID_DESIGNER = 9
 TT_NAME_ID_DESCRIPTION = 10
@@ -688,11 +692,26 @@ TT_NAME_ID_VENDOR_URL = 11
 TT_NAME_ID_DESIGNER_URL = 12
 TT_NAME_ID_LICENSE = 13
 TT_NAME_ID_LICENSE_URL = 14
+# 15 is reserved.
 TT_NAME_ID_PREFERRED_FAMILY = 16
 TT_NAME_ID_PREFERRED_SUBFAMILY = 17
 TT_NAME_ID_MAC_FULL_NAME = 18
+TT_NAME_ID_SAMPLE_TEXT = 19
+
+# OpenType 1.3
 TT_NAME_ID_CID_FINDFONT_NAME = 20
 
+# OpenType 1.5
+TT_NAME_ID_WWS_FAMILY = 21
+TT_NAME_ID_WWS_SUBFAMILY = 22
+
+# OpenType 1.7
+TT_NAME_ID_LIGHT_BACKGROUND = 23
+TT_NAME_ID_DARK_BACKGROUND = 24
+
+# OpenType 1.8
+TT_NAME_ID_VARIATIONS_PREFIX = 25
+
 _library = None