Merge branch 'libraqm-vector' into libraqm-full

Author: QuLogic

ci/mypy-stubtest-allowlist.txt

@@ -6,6 +6,7 @@ matplotlib\._.*
 matplotlib\.rcsetup\._listify_validator
 matplotlib\.rcsetup\._validate_linestyle
 matplotlib\.ft2font\.Glyph
+matplotlib\.ft2font\.LayoutItem
 matplotlib\.testing\.jpl_units\..*
 matplotlib\.sphinxext(\..*)?
 

lib/matplotlib/_text_helpers.py

@@ -4,29 +4,23 @@
 
 from __future__ import annotations
 
-import dataclasses
+from collections.abc import Iterator
 
 from . import _api
-from .ft2font import FT2Font, GlyphIndexType, Kerning, LoadFlags
+from .ft2font import FT2Font, CharacterCodeType, LayoutItem, LoadFlags
 
 
-@dataclasses.dataclass(frozen=True)
-class LayoutItem:
-    ft_object: FT2Font
-    char: str
-    glyph_index: GlyphIndexType
-    x: float
-    prev_kern: float
-
-
-def warn_on_missing_glyph(codepoint, fontnames):
+def warn_on_missing_glyph(codepoint: CharacterCodeType, fontnames: str):
     _api.warn_external(
         f"Glyph {codepoint} "
         f"({chr(codepoint).encode('ascii', 'namereplace').decode('ascii')}) "
         f"missing from font(s) {fontnames}.")
 
 
-def layout(string, font, *, features=None, kern_mode=Kerning.DEFAULT, language=None):
+def layout(string: str, font: FT2Font, *,
+           features: tuple[str] | None = None,
+           language: str | tuple[tuple[str, int, int], ...] | None = None
+           ) -> Iterator[LayoutItem]:
     """
     Render *string* with *font*.
 
@@ -41,8 +35,6 @@ def layout(string, font, *, features=None, kern_mode=Kerning.DEFAULT, language=N
         The font.
     features : tuple of str, optional
         The font features to apply to the text.
-    kern_mode : Kerning
-        A FreeType kerning mode.
     language : str, optional
         The language of the text in a format accepted by libraqm, namely `a BCP47
         language code <https://www.w3.org/International/articles/language-tags/>`_.
@@ -51,20 +43,8 @@ def layout(string, font, *, features=None, kern_mode=Kerning.DEFAULT, language=N
     ------
     LayoutItem
     """
-    x = 0
-    prev_glyph_index = None
-    char_to_font = font._get_fontmap(string)  # TODO: Pass in features and language.
-    base_font = font
-    for char in string:
-        # This has done the fallback logic
-        font = char_to_font.get(char, base_font)
-        glyph_index = font.get_char_index(ord(char))
-        kern = (
-            base_font.get_kerning(prev_glyph_index, glyph_index, kern_mode) / 64
-            if prev_glyph_index is not None else 0.
-        )
-        x += kern
-        glyph = font.load_glyph(glyph_index, flags=LoadFlags.NO_HINTING)
-        yield LayoutItem(font, char, glyph_index, x, kern)
-        x += glyph.linearHoriAdvance / 65536
-        prev_glyph_index = glyph_index
+    for raqm_item in font._layout(string, LoadFlags.NO_HINTING,
+                                  features=features, language=language):
+        raqm_item.ft_object.load_glyph(raqm_item.glyph_index,
+                                       flags=LoadFlags.NO_HINTING)
+        yield raqm_item

lib/matplotlib/backends/_backend_pdf_ps.py

@@ -198,7 +198,10 @@ def __init__(self, subset_size: int = 0):
         self.glyph_maps: dict[str, GlyphMap] = {}
         self.subset_size = subset_size
 
-    def track(self, font: FT2Font, s: str) -> list[tuple[int, CharacterCodeType]]:
+    def track(self, font: FT2Font, s: str,
+              features: tuple[str, ...] | None = ...,
+              language: str | tuple[tuple[str, int, int], ...] | None = None
+              ) -> list[tuple[int, CharacterCodeType]]:
         """
         Record that string *s* is being typeset using font *font*.
 
@@ -208,6 +211,14 @@ def track(self, font: FT2Font, s: str) -> list[tuple[int, CharacterCodeType]]:
             A font that is being used for the provided string.
         s : str
             The string that should be marked as tracked by the provided font.
+        features : tuple[str, ...], optional
+            The font feature tags to use for the font.
+
+            Available font feature tags may be found at
+            https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist
+        language : str, optional
+            The language of the text in a format accepted by libraqm, namely `a BCP47
+            language code <https://www.w3.org/International/articles/language-tags/>`_.
 
         Returns
         -------
@@ -219,8 +230,9 @@ def track(self, font: FT2Font, s: str) -> list[tuple[int, CharacterCodeType]]:
             and the character codes will be returned from the string unchanged.
         """
         return [
-            self.track_glyph(f, ord(c), f.get_char_index(ord(c)))
-            for c, f in font._get_fontmap(s).items()
+            self.track_glyph(raqm_item.ft_object, raqm_item.char, raqm_item.glyph_index)
+            for raqm_item in font._layout(s, ft2font.LoadFlags.NO_HINTING,
+                                          features=features, language=language)
         ]
 
     def track_glyph(self, font: FT2Font, chars: str | CharacterCodeType,

lib/matplotlib/backends/backend_pdf.py

@@ -34,7 +34,7 @@
 from matplotlib.figure import Figure
 from matplotlib.font_manager import FontPath, get_font, fontManager as _fontManager
 from matplotlib._afm import AFM
-from matplotlib.ft2font import FT2Font, FaceFlags, Kerning, LoadFlags, StyleFlags
+from matplotlib.ft2font import FT2Font, FaceFlags, LoadFlags, StyleFlags
 from matplotlib.transforms import Affine2D, BboxBase
 from matplotlib.path import Path
 from matplotlib.dates import UTC
@@ -469,6 +469,7 @@ class Op(Enum):
     textpos = b'Td'
     selectfont = b'Tf'
     textmatrix = b'Tm'
+    textrise = b'Ts'
     show = b'Tj'
     showkern = b'TJ'
     setlinewidth = b'w'
@@ -2288,6 +2289,9 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
         # If fonttype is neither 3 nor 42, emit the whole string at once
         # without manual kerning.
         if fonttype not in [3, 42]:
+            if not mpl.rcParams['pdf.use14corefonts']:
+                self.file._character_tracker.track(font, s,
+                                                   features=features, language=language)
             self.file.output(Op.begin_text,
                              self.file.fontName(prop), fontsize, Op.selectfont)
             self._setup_textpos(x, y, angle)
@@ -2308,13 +2312,16 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
         # kerning between chunks.
         else:
             def output_singlebyte_chunk(kerns_or_chars):
+                if not kerns_or_chars:
+                    return
                 self.file.output(
                     # See pdf spec "Text space details" for the 1000/fontsize
                     # (aka. 1000/T_fs) factor.
                     [(-1000 * next(group) / fontsize) if tp == float  # a kern
                      else self._encode_glyphs(group, fonttype)
                      for tp, group in itertools.groupby(kerns_or_chars, type)],
                     Op.showkern)
+                kerns_or_chars.clear()
             # Do the rotation and global translation as a single matrix
             # concatenation up front
             self.file.output(Op.gsave)
@@ -2329,26 +2336,28 @@ def output_singlebyte_chunk(kerns_or_chars):
             # Emit all the characters in a BT/ET group.
             self.file.output(Op.begin_text)
             for item in _text_helpers.layout(s, font, features=features,
-                                             kern_mode=Kerning.UNFITTED,
                                              language=language):
                 subset, charcode = self.file._character_tracker.track_glyph(
                     item.ft_object, item.char, item.glyph_index)
                 if (item.ft_object, subset) != prev_font:
-                    if singlebyte_chunk:
-                        output_singlebyte_chunk(singlebyte_chunk)
+                    output_singlebyte_chunk(singlebyte_chunk)
                     font_path = FontPath(item.ft_object.fname,
                                          item.ft_object.face_index)
                     ft_name = self.file.fontName(font_path, subset)
                     self.file.output(ft_name, fontsize, Op.selectfont)
                     self._setup_textpos(item.x, 0, 0, prev_start_x, 0, 0)
-                    singlebyte_chunk = []
                     prev_font = (item.ft_object, subset)
                     prev_start_x = item.x
+                if item.y:
+                    output_singlebyte_chunk(singlebyte_chunk)
+                    self.file.output(item.y, Op.textrise)
                 if item.prev_kern:
                     singlebyte_chunk.append(item.prev_kern)
                 singlebyte_chunk.append(charcode)
-            if singlebyte_chunk:
-                output_singlebyte_chunk(singlebyte_chunk)
+                if item.y:
+                    output_singlebyte_chunk(singlebyte_chunk)
+                    self.file.output(0, Op.textrise)
+            output_singlebyte_chunk(singlebyte_chunk)
             self.file.output(Op.end_text)
             self.file.output(Op.grestore)
 

lib/matplotlib/backends/backend_ps.py

@@ -772,7 +772,7 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
         if ismath:
             return self.draw_mathtext(gc, x, y, s, prop, angle)
 
-        stream = []  # list of (ps_name, x, char_name)
+        stream = []  # list of (ps_name, x, y, char_name)
 
         if mpl.rcParams['ps.useafm']:
             font = self._get_font_afm(prop)
@@ -790,7 +790,7 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
                 kern = font.get_kern_dist_from_name(last_name, name)
                 last_name = name
                 thisx += kern * scale
-                stream.append((ps_name, thisx, name))
+                stream.append((ps_name, thisx, 0, name))
                 thisx += width * scale
 
         else:
@@ -810,14 +810,13 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
                 ps_name = (item.ft_object.postscript_name
                            .encode("ascii", "replace").decode("ascii"))
                 glyph_name = item.ft_object.get_glyph_name(item.glyph_index)
-                stream.append((f'{ps_name}-{subset}', item.x, glyph_name))
+                stream.append((f'{ps_name}-{subset}', item.x, item.y, glyph_name))
         self.set_color(*gc.get_rgb())
 
-        for ps_name, group in itertools. \
-                groupby(stream, lambda entry: entry[0]):
+        for ps_name, group in itertools.groupby(stream, lambda entry: entry[0]):
             self.set_font(ps_name, prop.get_size_in_points(), False)
-            thetext = "\n".join(f"{x:g} 0 m /{name:s} glyphshow"
-                                for _, x, name in group)
+            thetext = "\n".join(f"{x:g} {y:g} m /{name:s} glyphshow"
+                                for _, x, y, name in group)
             self._pswriter.write(f"""\
 gsave
 {self._get_clip_cmd(gc)}

lib/matplotlib/backends/backend_svg.py

@@ -1048,6 +1048,11 @@ def _draw_text_as_path(self, gc, x, y, s, prop, angle, ismath, mtext=None):
         text2path = self._text2path
         color = rgb2hex(gc.get_rgb())
         fontsize = prop.get_size_in_points()
+        if mtext is not None:
+            features = mtext.get_fontfeatures()
+            language = mtext.get_language()
+        else:
+            features = language = None
 
         style = {}
         if color != '#000000':
@@ -1068,7 +1073,8 @@ def _draw_text_as_path(self, gc, x, y, s, prop, angle, ismath, mtext=None):
         if not ismath:
             font = text2path._get_font(prop)
             glyph_info, glyph_map_new, rects = text2path.get_glyphs_with_font(
-                font, s, glyph_map=glyph_map, return_new_glyphs_only=True)
+                font, s, features=features, language=language,
+                glyph_map=glyph_map, return_new_glyphs_only=True)
             self._update_glyph_map_defs(glyph_map_new)
 
             for glyph_repr, xposition, yposition, scale in glyph_info:

lib/matplotlib/ft2font.pyi

@@ -199,6 +199,22 @@ class _SfntPcltDict(TypedDict):
     widthType: int
     serifStyle: int
 
+@final
+class LayoutItem:
+    @property
+    def ft_object(self) -> FT2Font: ...
+    @property
+    def char(self) -> str: ...
+    @property
+    def glyph_index(self) -> GlyphIndexType: ...
+    @property
+    def x(self) -> float: ...
+    @property
+    def y(self) -> float: ...
+    @property
+    def prev_kern(self) -> float: ...
+    def __str__(self) -> str: ...
+
 @final
 class FT2Font(Buffer):
     def __init__(
@@ -212,7 +228,13 @@ class FT2Font(Buffer):
     ) -> None: ...
     if sys.version_info[:2] >= (3, 12):
         def __buffer__(self, flags: int) -> memoryview: ...
-    def _get_fontmap(self, string: str) -> dict[str, FT2Font]: ...
+    def _layout(
+        self,
+        text: str,
+        flags: LoadFlags,
+        features: tuple[str, ...] | None = ...,
+        language: str | tuple[tuple[str, int, int], ...] | None = ...,
+    ) -> list[LayoutItem]: ...
     def clear(self) -> None: ...
     def draw_glyph_to_bitmap(
         self, image: NDArray[np.uint8], x: int, y: int, glyph: Glyph, antialiased: bool = ...