Font.cpp

@@RefPtr<Font> Font::createScaledFont(const FontDescription& fontDescription, floa

    return platformCreateScaledFont(fontDescription, scaleFactor);

}

544 #if !USE(CO~~RE_TEXT~~)

544#if USE(HARFBUZZ)

GlyphBufferAdvance Font::applyTransforms(GlyphBuffer&, unsigned, unsigned, bool, bool, const AtomString&, StringView, TextDirection) const

{

    return makeGlyphBufferAdvance();

Source/WebCore/platform/graphics/Font.h

@@public:

#endif

    bool canRenderCombiningCharacterSequence(const UChar*, size_t) const;

209 GlyphBufferAdvance applyTransforms(GlyphBuffer&, unsigned beginningGlyphIndex, unsigned beginningStringIndex, bool enableKerning, bool requiresShaping, const AtomString& locale, StringView text, TextDirection) const;

209 GlyphBufferAdvance applyTransforms(GlyphBuffer&, unsigned beginningGlyphIndex, unsigned beginningStringIndex, unsigned stringLength, bool enableKerning, bool requiresShaping, const AtomString& locale, StringView text, TextDirection) const;

    // Returns nullopt if none of the glyphs are OT-SVG glyphs.

    std::optional<BitVector> findOTSVGGlyphs(const GlyphBufferGlyph*, unsigned count) const;

Source/WebCore/platform/graphics/FontCascade.cpp

@@float FontCascade::widthForSimpleText(StringView text, TextDirection textDirecti

        glyphBuffer.add(glyph, font, glyphWidth, i);

    }

324 auto initialAdvance = font.applyTransforms(glyphBuffer, 0, 0, enableKerning(), requiresShaping(), fontDescription().computedLocale(), text, textDirection);

324 auto initialAdvance = font.applyTransforms(glyphBuffer, 0, 0, text.length(), enableKerning(), requiresShaping(), fontDescription().computedLocale(), text, textDirection);

    // This is needed only to match the result of the slow path.

    // Same glyph widths but different floating point arithmetic can produce different run width.

    float runWidthDifferenceWithTransformApplied = -runWidth;

Source/WebCore/platform/graphics/WidthIterator.cpp

@@static inline bool isSoftBankEmoji(UChar32 codepoint)

    return codepoint >= 0xE001 && codepoint <= 0xE537;

}

83 inline auto WidthIterator::applyFontTransforms(GlyphBuffer& glyphBuffer, unsigned lastGlyphCount, const Font& font, CharactersTreatedAsSpace& charactersTreatedAsSpace) -> ApplyFontTransformsResult

83inline auto WidthIterator::applyFontTransforms(GlyphBuffer& glyphBuffer, unsigned lastGlyphCount, unsigned stringLength, const Font& font, CharactersTreatedAsSpace& charactersTreatedAsSpace) -> ApplyFontTransformsResult

{

    auto glyphBufferSize = glyphBuffer.size();

    ASSERT(lastGlyphCount <= glyphBufferSize);

@@inline auto WidthIterator::applyFontTransforms(GlyphBuffer& glyphBuffer, unsigne

    for (unsigned i = lastGlyphCount; i < glyphBufferSize; ++i)

        beforeWidth += width(advances[i]);

95 auto initialAdvance = font.applyTransforms(glyphBuffer, lastGlyphCount, m_currentCharacterIndex, m_enableKerning, m_requiresShaping, m_font.fontDescription().computedLocale(), m_run.text(), m_run.direction());

95 auto initialAdvance = font.applyTransforms(glyphBuffer, lastGlyphCount, m_currentCharacterIndex, stringLength,

96 m_enableKerning, m_requiresShaping, m_font.fontDescription().computedLocale(), m_run.text(), m_run.direction());

#if USE(CTFONTSHAPEGLYPHS_WORKAROUND)

    // <rdar://problem/80798113>: If a character is not in BMP, and we don't have a glyph for it,

@@void WidthIterator::commitCurrentFontRange(GlyphBuffer& glyphBuffer, unsigned& l

        ASSERT(&glyphBuffer.fontAt(i) == font);

#endif

218 auto applyFontTransformsResult = applyFontTransforms(glyphBuffer, lastGlyphCount, *font, charactersTreatedAsSpace);

219 auto applyFontTransformsResult = applyFontTransforms(glyphBuffer, lastGlyphCount, currentCharacterIndex - m_currentCharacterIndex, *font, charactersTreatedAsSpace);

    m_runWidthSoFar += applyFontTransformsResult.additionalAdvance;

    applyInitialAdvance(glyphBuffer, applyFontTransformsResult.initialAdvance, lastGlyphCount);

    m_currentCharacterIndex = currentCharacterIndex;

Source/WebCore/platform/graphics/WidthIterator.h

@@private:

        float additionalAdvance;

        GlyphBufferAdvance initialAdvance;

    };

70 ApplyFontTransformsResult applyFontTransforms(GlyphBuffer&, unsigned lastGlyphCount, const Font&, CharactersTreatedAsSpace&);

70 ApplyFontTransformsResult applyFontTransforms(GlyphBuffer&, unsigned lastGlyphCount, unsigned stringLength, const Font&, CharactersTreatedAsSpace&);

    void commitCurrentFontRange(GlyphBuffer&, unsigned& lastGlyphCount, unsigned currentCharacterIndex, const Font*&, const Font& newFont, const Font& primaryFont, UChar32 character, float& widthOfCurrentFontRange, float nextCharacterWidth, CharactersTreatedAsSpace&);

    void applyInitialAdvance(GlyphBuffer&, GlyphBufferAdvance initialAdvance, unsigned lastGlyphCount);

Source/WebCore/platform/graphics/win/ComplexTextControllerUniscribe.cpp

@@void ComplexTextController::collectComplexTextRunsForCharacters(const UChar* cp,

    }

}

GlyphBufferAdvance Font::applyTransforms(GlyphBuffer& glyphBuffer, unsigned beginningGlyphIndex, unsigned beginningStringIndex, unsigned stringLength, bool enableKerning, bool requiresShaping, const AtomString& locale, StringView text, TextDirection textDirection) const

{

    glyphBuffer.remove(beginningGlyphIndex, glyphBuffer.size() - beginningGlyphIndex);

    auto substring = text.substring(beginningStringIndex, stringLength);

    auto upconvertedCharacters = substring.upconvertedCharacters();

    Vector<SCRIPT_ITEM> items(6);

    int numItems = 0;

    for (;;) {

        SCRIPT_CONTROL control { };

        SCRIPT_STATE state { };

        control.fMergeNeutralItems = true;

        // Set up the correct direction for the run.

        state.uBidiLevel = textDirection == TextDirection::RTL;

        // Lock the correct directional override.

        // state.fOverrideDirection = ?

        // ScriptItemize may write (cMaxItems + 1) SCRIPT_ITEM.

        HRESULT hr = ScriptItemize(wcharFrom(upconvertedCharacters.get()), stringLength, items.size() - 1, &control, &state, items.data(), &numItems);

        if (hr != E_OUTOFMEMORY) {

            ASSERT(SUCCEEDED(hr));

            break;

        }

        items.resize(items.size() * 2);

    }

    items.resize(numItems + 1);

    for (int i = 0; i < numItems; i++) {

        // Determine the string for this item.

        const UChar* str = upconvertedCharacters.get() + items[i].iCharPos;

        int length = items[i+1].iCharPos - items[i].iCharPos;

        SCRIPT_ITEM& item = items[i];

        // Set up buffers to hold the results of shaping the item.

        Vector<WORD> glyphs;

        Vector<WORD> clusters;

        Vector<SCRIPT_VISATTR> visualAttributes;

        clusters.resize(length);

        // Shape the item.

        // The recommended size for the glyph buffer is 1.5 * the character length + 16 in the uniscribe docs.

        // Apparently this is a good size to avoid having to make repeated calls to ScriptShape.

        glyphs.resize(1.5 * length + 16);

        visualAttributes.resize(glyphs.size());

        if (!shapeByUniscribe(str, length, item, this, glyphs, clusters, visualAttributes))

            continue;

        // We now have a collection of glyphs.

        Vector<GOFFSET> offsets;

        Vector<int> advances;

        offsets.resize(glyphs.size());

        advances.resize(glyphs.size());

        HRESULT placeResult = ScriptPlace(0, scriptCache(), glyphs.data(), glyphs.size(), visualAttributes.data(),

            &item.a, advances.data(), offsets.data(), 0);

        if (placeResult == E_PENDING) {

            // The script cache isn't primed with enough info yet. We need to select our HFONT into

            // a DC and pass the DC in to ScriptPlace.

            HWndDC hdc(0);

            HFONT hfont = platformData().hfont();

            HGDIOBJ oldFont = SelectObject(hdc, hfont);

            placeResult = ScriptPlace(hdc, scriptCache(), glyphs.data(), glyphs.size(), visualAttributes.data(),

                &item.a, advances.data(), offsets.data(), 0);

            SelectObject(hdc, oldFont);

        }

        if (FAILED(placeResult) || glyphs.isEmpty())

            continue;

        bool ltr = !item.a.fRTL;

        auto stringIndices = stringIndicesFromClusters(clusters, StringView(str, length), beginningStringIndex + item.iCharPos, glyphs.size(), ltr);

        for (unsigned k = 0; k < glyphs.size(); k++) {

            const float cLogicalScale = platformData().useGDI() ? 1 : 32;

            float advance = advances[k] / cLogicalScale;

            float offsetX = offsets[k].du / cLogicalScale;

            float offsetY = offsets[k].dv / cLogicalScale;

            // Match AppKit's rules for the integer vs. non-integer rendering modes.

            if (!platformData().isSystemFont()) {

                advance = roundf(advance);

                offsetX = roundf(offsetX);

                offsetY = roundf(offsetY);

            }

            glyphBuffer.add(glyphs[k], *this, { advance, 0 }, stringIndices[k]);

            glyphBuffer.origins(k)[0] = makeGlyphBufferOrigin(offsetX, offsetY);

        }

    }

    return makeGlyphBufferAdvance();

}

}

#endif // !USE(DIRECT2D)