Implement text shaping with libraqm

Author: QuLogic

lib/matplotlib/_text_helpers.py

@@ -25,23 +25,6 @@ def warn_on_missing_glyph(codepoint, fontnames):
         f"({chr(codepoint).encode('ascii', 'namereplace').decode('ascii')}) "
         f"missing from font(s) {fontnames}.")
 
-    block = ("Hebrew" if 0x0590 <= codepoint <= 0x05ff else
-             "Arabic" if 0x0600 <= codepoint <= 0x06ff else
-             "Devanagari" if 0x0900 <= codepoint <= 0x097f else
-             "Bengali" if 0x0980 <= codepoint <= 0x09ff else
-             "Gurmukhi" if 0x0a00 <= codepoint <= 0x0a7f else
-             "Gujarati" if 0x0a80 <= codepoint <= 0x0aff else
-             "Oriya" if 0x0b00 <= codepoint <= 0x0b7f else
-             "Tamil" if 0x0b80 <= codepoint <= 0x0bff else
-             "Telugu" if 0x0c00 <= codepoint <= 0x0c7f else
-             "Kannada" if 0x0c80 <= codepoint <= 0x0cff else
-             "Malayalam" if 0x0d00 <= codepoint <= 0x0d7f else
-             "Sinhala" if 0x0d80 <= codepoint <= 0x0dff else
-             None)
-    if block:
-        _api.warn_external(
-            f"Matplotlib currently does not support {block} natively.")
-
 
 def layout(string, font, *, kern_mode=Kerning.DEFAULT):
     """

lib/matplotlib/tests/test_text.py

@@ -817,18 +817,6 @@ def test_pdf_kerning():
     plt.figtext(0.1, 0.5, "ATATATATATATATATATA", size=30)
 
 
-def test_unsupported_script(recwarn):
-    fig = plt.figure()
-    t = fig.text(.5, .5, "\N{BENGALI DIGIT ZERO}")
-    fig.canvas.draw()
-    assert all(isinstance(warn.message, UserWarning) for warn in recwarn)
-    assert (
-        [warn.message.args for warn in recwarn] ==
-        [(r"Glyph 2534 (\N{BENGALI DIGIT ZERO}) missing from font(s) "
-            + f"{t.get_fontname()}.",),
-         (r"Matplotlib currently does not support Bengali natively.",)])
-
-
 # See gh-26152 for more information on this xfail
 @pytest.mark.xfail(pyparsing_version.release == (3, 1, 0),
                    reason="Error messages are incorrect with pyparsing 3.1.0")

src/ft2font.cpp

@@ -271,6 +271,11 @@ FT2Font::FT2Font(FT_Open_Args &open_args,
         throw_ft_error("Can not load face", error);
     }
 
+    // This allows us to get back to our data if we need it, though it makes a pointer
+    // loop, so don't set a free-function for it.
+    face->generic.data = this;
+    face->generic.finalizer = nullptr;
+
     // set a default fontsize 12 pt at 72dpi
     error = FT_Set_Char_Size(face, 12 * 64, 0, 72 * (unsigned int)hinting_factor, 72);
     if (error) {
@@ -417,62 +422,86 @@ void FT2Font::set_text(
     bbox.xMin = bbox.yMin = 32000;
     bbox.xMax = bbox.yMax = -32000;
 
-    FT_UInt previous = 0;
-    FT2Font *previous_ft_object = nullptr;
+    auto rq = raqm_create();
+    if (!rq) {
+        throw std::runtime_error("failed to compute text layout");
+    }
+    [[maybe_unused]] auto const& rq_cleanup =
+        std::unique_ptr<std::remove_pointer_t<raqm_t>, decltype(&raqm_destroy)>(
+            rq, raqm_destroy);
 
-    for (auto codepoint : text) {
-        FT_UInt glyph_index = 0;
-        FT_BBox glyph_bbox;
-        FT_Pos last_advance;
+    if (!raqm_set_text(rq, reinterpret_cast<const uint32_t *>(text.data()), text.size())) {
+        throw std::runtime_error("failed to set text for layout");
+    }
 
-        FT_Error charcode_error, glyph_error;
-        std::set<FT_String*> glyph_seen_fonts;
-        FT2Font *ft_object_with_glyph = this;
-        bool was_found = load_char_with_fallback(ft_object_with_glyph, glyph_index, glyphs,
-                                                 char_to_font, glyph_to_font, codepoint, flags,
-                                                 charcode_error, glyph_error, glyph_seen_fonts, false);
-        if (!was_found) {
-            ft_glyph_warn((FT_ULong)codepoint, glyph_seen_fonts);
-            // render missing glyph tofu
-            // come back to top-most font
-            ft_object_with_glyph = this;
-            char_to_font[codepoint] = ft_object_with_glyph;
-            glyph_to_font[glyph_index] = ft_object_with_glyph;
-            ft_object_with_glyph->load_glyph(glyph_index, flags, ft_object_with_glyph, false);
-        } else if (ft_object_with_glyph->warn_if_used) {
-            ft_glyph_warn((FT_ULong)codepoint, glyph_seen_fonts);
-        }
+    if (!raqm_set_freetype_face(rq, face)) {
+        throw std::runtime_error("failed to set text face for layout");
+    }
+
+    if (!raqm_set_freetype_load_flags(rq, flags)) {
+        throw std::runtime_error("failed to set text flags for layout");
+    }
+
+    std::set<FT_String*> glyph_seen_fonts;
+    glyph_seen_fonts.insert(face->family_name);
+
+    if (!raqm_layout(rq)) {
+        throw std::runtime_error("failed to layout text");
+    }
 
-        // retrieve kerning distance and move pen position
-        if ((ft_object_with_glyph == previous_ft_object) &&  // if both fonts are the same
-            ft_object_with_glyph->has_kerning() &&           // if the font knows how to kern
-            previous && glyph_index                          // and we really have 2 glyphs
-            ) {
-            FT_Vector delta;
-            pen.x += ft_object_with_glyph->get_kerning(previous, glyph_index, FT_KERNING_DEFAULT, delta);
+
+    size_t num_glyphs = 0;
+    auto const& rq_glyphs = raqm_get_glyphs(rq, &num_glyphs);
+
+    for (size_t i = 0; i < num_glyphs; i++) {
+        auto const& rglyph = rq_glyphs[i];
+
+        // Warn for missing glyphs.
+        if (rglyph.index == 0) {
+            ft_glyph_warn(text[rglyph.cluster], glyph_seen_fonts);
+            continue;
+        }
+        FT2Font *wrapped_font = static_cast<FT2Font *>(rglyph.ftface->generic.data);
+        if (wrapped_font->warn_if_used) {
+            ft_glyph_warn(text[rglyph.cluster], glyph_seen_fonts);
         }
 
         // extract glyph image and store it in our table
-        FT_Glyph &thisGlyph = glyphs[glyphs.size() - 1];
+        FT_Error error;
+        error = FT_Load_Glyph(rglyph.ftface, rglyph.index, flags);
+        if (error) {
+            throw std::runtime_error("failed to load glyph");
+        }
+        FT_Glyph thisGlyph;
+        error = FT_Get_Glyph(rglyph.ftface->glyph, &thisGlyph);
+        if (error) {
+            throw std::runtime_error("failed to get glyph");
+        }
+
+        pen.x += rglyph.x_offset;
+        pen.y += rglyph.y_offset;
 
-        last_advance = ft_object_with_glyph->get_face()->glyph->advance.x;
         FT_Glyph_Transform(thisGlyph, nullptr, &pen);
         FT_Glyph_Transform(thisGlyph, &matrix, nullptr);
         xys.push_back(pen.x);
         xys.push_back(pen.y);
 
+        FT_BBox glyph_bbox;
         FT_Glyph_Get_CBox(thisGlyph, FT_GLYPH_BBOX_SUBPIXELS, &glyph_bbox);
 
         bbox.xMin = std::min(bbox.xMin, glyph_bbox.xMin);
         bbox.xMax = std::max(bbox.xMax, glyph_bbox.xMax);
         bbox.yMin = std::min(bbox.yMin, glyph_bbox.yMin);
         bbox.yMax = std::max(bbox.yMax, glyph_bbox.yMax);
 
-        pen.x += last_advance;
-
-        previous = glyph_index;
-        previous_ft_object = ft_object_with_glyph;
+        if ((flags & FT_LOAD_NO_HINTING) != 0) {
+            pen.x += rglyph.x_advance - rglyph.x_offset;
+        } else {
+            pen.x += hinting_factor * rglyph.x_advance - rglyph.x_offset;
+        }
+        pen.y += rglyph.y_advance - rglyph.y_offset;
 
+        glyphs.push_back(thisGlyph);
     }
 
     FT_Vector_Transform(&pen, &matrix);