From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- gfx/thebes/gfxFT2FontBase.cpp | 217 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100644 gfx/thebes/gfxFT2FontBase.cpp (limited to 'gfx/thebes/gfxFT2FontBase.cpp') diff --git a/gfx/thebes/gfxFT2FontBase.cpp b/gfx/thebes/gfxFT2FontBase.cpp new file mode 100644 index 000000000..241f28f63 --- /dev/null +++ b/gfx/thebes/gfxFT2FontBase.cpp @@ -0,0 +1,217 @@ +/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "gfxFT2FontBase.h" +#include "gfxFT2Utils.h" +#include "harfbuzz/hb.h" +#include "mozilla/Likely.h" +#include "gfxFontConstants.h" +#include "gfxFontUtils.h" + +using namespace mozilla::gfx; + +gfxFT2FontBase::gfxFT2FontBase(cairo_scaled_font_t *aScaledFont, + gfxFontEntry *aFontEntry, + const gfxFontStyle *aFontStyle) + : gfxFont(aFontEntry, aFontStyle, kAntialiasDefault, aScaledFont), + mSpaceGlyph(0), + mHasMetrics(false) +{ + cairo_scaled_font_reference(mScaledFont); + gfxFT2LockedFace face(this); + mFUnitsConvFactor = face.XScale(); +} + +gfxFT2FontBase::~gfxFT2FontBase() +{ + cairo_scaled_font_destroy(mScaledFont); +} + +uint32_t +gfxFT2FontBase::GetGlyph(uint32_t aCharCode) +{ + // FcFreeTypeCharIndex needs to lock the FT_Face and can end up searching + // through all the postscript glyph names in the font. Therefore use a + // lightweight cache, which is stored on the cairo_font_face_t. + + cairo_font_face_t *face = + cairo_scaled_font_get_font_face(CairoScaledFont()); + + if (cairo_font_face_status(face) != CAIRO_STATUS_SUCCESS) + return 0; + + // This cache algorithm and size is based on what is done in + // cairo_scaled_font_text_to_glyphs and pango_fc_font_real_get_glyph. I + // think the concept is that adjacent characters probably come mostly from + // one Unicode block. This assumption is probably not so valid with + // scripts with large character sets as used for East Asian languages. + + struct CmapCacheSlot { + uint32_t mCharCode; + uint32_t mGlyphIndex; + }; + const uint32_t kNumSlots = 256; + static cairo_user_data_key_t sCmapCacheKey; + + CmapCacheSlot *slots = static_cast + (cairo_font_face_get_user_data(face, &sCmapCacheKey)); + + if (!slots) { + // cairo's caches can keep some cairo_font_faces alive past our last + // destroy, so the destroy function (free) for the cache must be + // callable from cairo without any assumptions about what other + // modules have not been shutdown. + slots = static_cast + (calloc(kNumSlots, sizeof(CmapCacheSlot))); + if (!slots) + return 0; + + cairo_status_t status = + cairo_font_face_set_user_data(face, &sCmapCacheKey, slots, free); + if (status != CAIRO_STATUS_SUCCESS) { // OOM + free(slots); + return 0; + } + + // Invalidate slot 0 by setting its char code to something that would + // never end up in slot 0. All other slots are already invalid + // because they have mCharCode = 0 and a glyph for char code 0 will + // always be in the slot 0. + slots[0].mCharCode = 1; + } + + CmapCacheSlot *slot = &slots[aCharCode % kNumSlots]; + if (slot->mCharCode != aCharCode) { + slot->mCharCode = aCharCode; + slot->mGlyphIndex = gfxFT2LockedFace(this).GetGlyph(aCharCode); + } + + return slot->mGlyphIndex; +} + +void +gfxFT2FontBase::GetGlyphExtents(uint32_t aGlyph, cairo_text_extents_t* aExtents) +{ + NS_PRECONDITION(aExtents != nullptr, "aExtents must not be NULL"); + + cairo_glyph_t glyphs[1]; + glyphs[0].index = aGlyph; + glyphs[0].x = 0.0; + glyphs[0].y = 0.0; + // cairo does some caching for us here but perhaps a small gain could be + // made by caching more. It is usually only the advance that is needed, + // so caching only the advance could allow many requests to be cached with + // little memory use. Ideally this cache would be merged with + // gfxGlyphExtents. + cairo_scaled_font_glyph_extents(CairoScaledFont(), glyphs, 1, aExtents); +} + +const gfxFont::Metrics& +gfxFT2FontBase::GetHorizontalMetrics() +{ + if (mHasMetrics) + return mMetrics; + + if (MOZ_UNLIKELY(GetStyle()->size <= 0.0) || + MOZ_UNLIKELY(GetStyle()->sizeAdjust == 0.0)) { + new(&mMetrics) gfxFont::Metrics(); // zero initialize + mSpaceGlyph = GetGlyph(' '); + } else { + gfxFT2LockedFace face(this); + face.GetMetrics(&mMetrics, &mSpaceGlyph); + } + + SanitizeMetrics(&mMetrics, false); + +#if 0 + // printf("font name: %s %f\n", NS_ConvertUTF16toUTF8(GetName()).get(), GetStyle()->size); + // printf ("pango font %s\n", pango_font_description_to_string (pango_font_describe (font))); + + fprintf (stderr, "Font: %s\n", NS_ConvertUTF16toUTF8(GetName()).get()); + fprintf (stderr, " emHeight: %f emAscent: %f emDescent: %f\n", mMetrics.emHeight, mMetrics.emAscent, mMetrics.emDescent); + fprintf (stderr, " maxAscent: %f maxDescent: %f\n", mMetrics.maxAscent, mMetrics.maxDescent); + fprintf (stderr, " internalLeading: %f externalLeading: %f\n", mMetrics.externalLeading, mMetrics.internalLeading); + fprintf (stderr, " spaceWidth: %f aveCharWidth: %f xHeight: %f\n", mMetrics.spaceWidth, mMetrics.aveCharWidth, mMetrics.xHeight); + fprintf (stderr, " uOff: %f uSize: %f stOff: %f stSize: %f\n", mMetrics.underlineOffset, mMetrics.underlineSize, mMetrics.strikeoutOffset, mMetrics.strikeoutSize); +#endif + + mHasMetrics = true; + return mMetrics; +} + +// Get the glyphID of a space +uint32_t +gfxFT2FontBase::GetSpaceGlyph() +{ + GetHorizontalMetrics(); + return mSpaceGlyph; +} + +uint32_t +gfxFT2FontBase::GetGlyph(uint32_t unicode, uint32_t variation_selector) +{ + if (variation_selector) { + uint32_t id = + gfxFT2LockedFace(this).GetUVSGlyph(unicode, variation_selector); + if (id) { + return id; + } + unicode = gfxFontUtils::GetUVSFallback(unicode, variation_selector); + if (unicode) { + return GetGlyph(unicode); + } + return 0; + } + + return GetGlyph(unicode); +} + +int32_t +gfxFT2FontBase::GetGlyphWidth(DrawTarget& aDrawTarget, uint16_t aGID) +{ + cairo_text_extents_t extents; + GetGlyphExtents(aGID, &extents); + // convert to 16.16 fixed point + return NS_lround(0x10000 * extents.x_advance); +} + +bool +gfxFT2FontBase::SetupCairoFont(DrawTarget* aDrawTarget) +{ + // The scaled font ctm is not relevant right here because + // cairo_set_scaled_font does not record the scaled font itself, but + // merely the font_face, font_matrix, font_options. The scaled_font used + // for the target can be different from the scaled_font passed to + // cairo_set_scaled_font. (Unfortunately we have measured only for an + // identity ctm.) + cairo_scaled_font_t *cairoFont = CairoScaledFont(); + + if (cairo_scaled_font_status(cairoFont) != CAIRO_STATUS_SUCCESS) { + // Don't cairo_set_scaled_font as that would propagate the error to + // the cairo_t, precluding any further drawing. + return false; + } + // Thoughts on which font_options to set on the context: + // + // cairoFont has been created for screen rendering. + // + // When the context is being used for screen rendering, we should set + // font_options such that the same scaled_font gets used (when the ctm is + // the same). The use of explicit font_options recorded in + // CreateScaledFont ensures that this will happen. + // + // XXXkt: For pdf and ps surfaces, I don't know whether it's better to + // remove surface-specific options, or try to draw with the same + // scaled_font that was used to measure. As the same font_face is being + // used, its font_options will often override some values anyway (unless + // perhaps we remove those from the FcPattern at face creation). + // + // I can't see any significant difference in printing, irrespective of + // what is set here. It's too late to change things here as measuring has + // already taken place. We should really be measuring with a different + // font for pdf and ps surfaces (bug 403513). + cairo_set_scaled_font(gfxFont::RefCairo(aDrawTarget), cairoFont); + return true; +} -- cgit v1.2.3