DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity
flutter_flutter/sky/engine/platform/fonts/Font.cpp
Eric Seidel 68e5c9bebe Fix 2 crashers found by Hixie's fuzzer. 
The first one is that we weren't setting up a
FontCachePurgePreventer during drawText.  It's not clear
that this is the correct fix, since Blink doesn't have
this FontCachePurgePreventer here either, but it's also
possible that they would hit this same ASSERT and just
not care (since ASSERTs are disabled on clusterfuzz).

The second fix is making ExceptionState actually track
whether it has thrown an exception or not. The c++ code
was depending on this working in order to return early
from dom functions and not crash!

R=abarth@google.com
2015-07-21 16:29:04 -07:00

844 lines
33 KiB
C++
Raw Blame History

/*
* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
* (C) 1999 Antti Koivisto (koivisto@kde.org)
* (C) 2000 Dirk Mueller (mueller@kde.org)
* Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include "sky/engine/platform/fonts/Font.h"
#include "gen/sky/platform/RuntimeEnabledFeatures.h"
#include "sky/engine/platform/LayoutUnit.h"
#include "sky/engine/platform/fonts/Character.h"
#include "sky/engine/platform/fonts/FontCache.h"
#include "sky/engine/platform/fonts/FontFallbackList.h"
#include "sky/engine/platform/fonts/FontPlatformFeatures.h"
#include "sky/engine/platform/fonts/GlyphBuffer.h"
#include "sky/engine/platform/fonts/GlyphPageTreeNode.h"
#include "sky/engine/platform/fonts/SimpleFontData.h"
#include "sky/engine/platform/fonts/WidthIterator.h"
#include "sky/engine/platform/fonts/harfbuzz/HarfBuzzShaper.h"
#include "sky/engine/platform/geometry/FloatRect.h"
#include "sky/engine/platform/graphics/GraphicsContext.h"
#include "sky/engine/platform/text/TextRun.h"
#include "sky/engine/wtf/MainThread.h"
#include "sky/engine/wtf/StdLibExtras.h"
#include "sky/engine/wtf/unicode/CharacterNames.h"
#include "sky/engine/wtf/unicode/Unicode.h"
using namespace WTF;
using namespace Unicode;
namespace blink {
CodePath Font::s_codePath = AutoPath;
// ============================================================================================
// Font Implementation (Cross-Platform Portion)
// ============================================================================================
Font::Font()
{
}
Font::Font(const FontDescription& fd)
: m_fontDescription(fd)
{
}
Font::Font(const Font& other)
: m_fontDescription(other.m_fontDescription)
, m_fontFallbackList(other.m_fontFallbackList)
{
}
Font& Font::operator=(const Font& other)
{
m_fontDescription = other.m_fontDescription;
m_fontFallbackList = other.m_fontFallbackList;
return *this;
}
bool Font::operator==(const Font& other) const
{
// Our FontData don't have to be checked, since checking the font description will be fine.
// FIXME: This does not work if the font was made with the FontPlatformData constructor.
if (loadingCustomFonts() || other.loadingCustomFonts())
return false;
FontSelector* first = m_fontFallbackList ? m_fontFallbackList->fontSelector() : 0;
FontSelector* second = other.m_fontFallbackList ? other.m_fontFallbackList->fontSelector() : 0;
return first == second
&& m_fontDescription == other.m_fontDescription
&& (m_fontFallbackList ? m_fontFallbackList->fontSelectorVersion() : 0) == (other.m_fontFallbackList ? other.m_fontFallbackList->fontSelectorVersion() : 0)
&& (m_fontFallbackList ? m_fontFallbackList->generation() : 0) == (other.m_fontFallbackList ? other.m_fontFallbackList->generation() : 0);
}
void Font::update(PassRefPtr<FontSelector> fontSelector) const
{
// FIXME: It is pretty crazy that we are willing to just poke into a RefPtr, but it ends up
// being reasonably safe (because inherited fonts in the render tree pick up the new
// style anyway. Other copies are transient, e.g., the state in the GraphicsContext, and
// won't stick around long enough to get you in trouble). Still, this is pretty disgusting,
// and could eventually be rectified by using RefPtrs for Fonts themselves.
if (!m_fontFallbackList)
m_fontFallbackList = FontFallbackList::create();
m_fontFallbackList->invalidate(fontSelector);
}
float Font::buildGlyphBuffer(const TextRunPaintInfo& runInfo, GlyphBuffer& glyphBuffer,
ForTextEmphasisOrNot forTextEmphasis) const
{
if (codePath(runInfo.run) == ComplexPath) {
HarfBuzzShaper shaper(this, runInfo.run, (forTextEmphasis == ForTextEmphasis)
? HarfBuzzShaper::ForTextEmphasis : HarfBuzzShaper::NotForTextEmphasis);
shaper.setDrawRange(runInfo.from, runInfo.to);
shaper.shape(&glyphBuffer);
return 0;
}
WidthIterator it(this, runInfo.run, nullptr, false, forTextEmphasis);
it.advance(runInfo.from);
float beforeWidth = it.runWidthSoFar();
it.advance(runInfo.to, &glyphBuffer);
if (runInfo.run.ltr())
return beforeWidth;
// RTL
float afterWidth = it.runWidthSoFar();
it.advance(runInfo.run.length());
glyphBuffer.reverse();
return it.runWidthSoFar() - afterWidth;
}
void Font::drawText(GraphicsContext* context, const TextRunPaintInfo& runInfo,
const FloatPoint& point) const
{
// Don't draw anything while we are using custom fonts that are in the process of loading.
if (shouldSkipDrawing())
return;
TextDrawingModeFlags textMode = context->textDrawingMode();
if (!(textMode & TextModeFill) && !((textMode & TextModeStroke) && context->hasStroke()))
return;
if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
// we have a pre-cached blob -- happy joy!
drawTextBlob(context, runInfo.cachedTextBlob->get(), point.data());
return;
}
{
FontCachePurgePreventer preventer;
GlyphBuffer glyphBuffer;
float initialAdvance = buildGlyphBuffer(runInfo, glyphBuffer);
if (glyphBuffer.isEmpty())
return;
if (RuntimeEnabledFeatures::textBlobEnabled()) {
// Enabling text-blobs forces the blob rendering path even for uncacheable blobs.
TextBlobPtr uncacheableTextBlob;
TextBlobPtr& textBlob = runInfo.cachedTextBlob ? *runInfo.cachedTextBlob : uncacheableTextBlob;
FloatRect blobBounds = runInfo.bounds;
blobBounds.moveBy(-point);
textBlob = buildTextBlob(glyphBuffer, initialAdvance, blobBounds);
if (textBlob) {
drawTextBlob(context, textBlob.get(), point.data());
return;
}
}
drawGlyphBuffer(context, runInfo, glyphBuffer, FloatPoint(point.x() + initialAdvance, point.y()));
}
}
float Font::drawUncachedText(GraphicsContext* context, const TextRunPaintInfo& runInfo,
const FloatPoint& point, CustomFontNotReadyAction customFontNotReadyAction) const
{
// Don't draw anything while we are using custom fonts that are in the process of loading,
// except if the 'force' argument is set to true (in which case it will use a fallback
// font).
if (shouldSkipDrawing() && customFontNotReadyAction == DoNotPaintIfFontNotReady)
return 0;
TextDrawingModeFlags textMode = context->textDrawingMode();
if (!(textMode & TextModeFill) && !((textMode & TextModeStroke) && context->hasStroke()))
return 0;
GlyphBuffer glyphBuffer;
float initialAdvance = buildGlyphBuffer(runInfo, glyphBuffer);
if (glyphBuffer.isEmpty())
return 0;
return drawGlyphBuffer(context, runInfo, glyphBuffer, FloatPoint(point.x() + initialAdvance, point.y()));
}
void Font::drawEmphasisMarks(GraphicsContext* context, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point) const
{
if (shouldSkipDrawing())
return;
GlyphBuffer glyphBuffer;
float initialAdvance = buildGlyphBuffer(runInfo, glyphBuffer, ForTextEmphasis);
if (glyphBuffer.isEmpty())
return;
drawEmphasisMarks(context, runInfo, glyphBuffer, mark, FloatPoint(point.x() + initialAdvance, point.y()));
}
static inline void updateGlyphOverflowFromBounds(const IntRectExtent& glyphBounds,
const FontMetrics& fontMetrics, GlyphOverflow* glyphOverflow)
{
glyphOverflow->top = std::max<int>(glyphOverflow->top,
glyphBounds.top() - (glyphOverflow->computeBounds ? 0 : fontMetrics.ascent()));
glyphOverflow->bottom = std::max<int>(glyphOverflow->bottom,
glyphBounds.bottom() - (glyphOverflow->computeBounds ? 0 : fontMetrics.descent()));
glyphOverflow->left = glyphBounds.left();
glyphOverflow->right = glyphBounds.right();
}
float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
{
CodePath codePathToUse = codePath(run);
if (codePathToUse != ComplexPath) {
// The simple path can optimize the case where glyph overflow is not observable.
if (codePathToUse != SimpleWithGlyphOverflowPath && (glyphOverflow && !glyphOverflow->computeBounds))
glyphOverflow = 0;
}
bool hasWordSpacingOrLetterSpacing = fontDescription().wordSpacing() || fontDescription().letterSpacing();
bool isCacheable = codePathToUse == ComplexPath
&& !hasWordSpacingOrLetterSpacing // Word spacing and letter spacing can change the width of a word.
&& !run.allowTabs(); // If we allow tabs and a tab occurs inside a word, the width of the word varies based on its position on the line.
WidthCacheEntry* cacheEntry = isCacheable
? m_fontFallbackList->widthCache().add(run, WidthCacheEntry())
: 0;
if (cacheEntry && cacheEntry->isValid()) {
if (glyphOverflow)
updateGlyphOverflowFromBounds(cacheEntry->glyphBounds, fontMetrics(), glyphOverflow);
return cacheEntry->width;
}
float result;
IntRectExtent glyphBounds;
if (codePathToUse == ComplexPath) {
result = floatWidthForComplexText(run, fallbackFonts, &glyphBounds);
} else {
ASSERT(!isCacheable);
result = floatWidthForSimpleText(run, fallbackFonts, glyphOverflow ? &glyphBounds : 0);
}
if (cacheEntry && (!fallbackFonts || fallbackFonts->isEmpty())) {
cacheEntry->glyphBounds = glyphBounds;
cacheEntry->width = result;
}
if (glyphOverflow)
updateGlyphOverflowFromBounds(glyphBounds, fontMetrics(), glyphOverflow);
return result;
}
float Font::width(const TextRun& run, int& charsConsumed, Glyph& glyphId) const
{
charsConsumed = run.length();
glyphId = 0;
return width(run);
}
FloatRect Font::selectionRectForText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
{
to = (to == -1 ? run.length() : to);
CodePath codePathToUse = codePath(run);
// FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
if (codePathToUse != ComplexPath && fontDescription().typesettingFeatures() && (from || to != run.length()))
codePathToUse = ComplexPath;
if (codePathToUse != ComplexPath)
return selectionRectForSimpleText(run, point, h, from, to, accountForGlyphBounds);
return selectionRectForComplexText(run, point, h, from, to);
}
int Font::offsetForPosition(const TextRun& run, float x, bool includePartialGlyphs) const
{
// FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
if (codePath(run) != ComplexPath && !fontDescription().typesettingFeatures())
return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
return offsetForPositionForComplexText(run, x, includePartialGlyphs);
}
void Font::setCodePath(CodePath p)
{
s_codePath = p;
}
CodePath Font::codePath()
{
return s_codePath;
}
CodePath Font::codePath(const TextRun& run) const
{
if (s_codePath != AutoPath)
return s_codePath;
if (m_fontDescription.featureSettings() && m_fontDescription.featureSettings()->size() > 0 && m_fontDescription.letterSpacing() == 0)
return ComplexPath;
if (m_fontDescription.widthVariant() != RegularWidth)
return ComplexPath;
if (run.length() > 1 && fontDescription().typesettingFeatures())
return ComplexPath;
if (!run.characterScanForCodePath())
return SimplePath;
if (run.is8Bit())
return SimplePath;
// Start from 0 since drawing and highlighting also measure the characters before run->from.
return Character::characterRangeCodePath(run.characters16(), run.length());
}
void Font::willUseFontData(UChar32 character) const
{
const FontFamily& family = fontDescription().family();
if (m_fontFallbackList && m_fontFallbackList->fontSelector() && !family.familyIsEmpty())
m_fontFallbackList->fontSelector()->willUseFontData(fontDescription(), family.family(), character);
}
static inline bool isInRange(UChar32 character, UChar32 lowerBound, UChar32 upperBound)
{
return character >= lowerBound && character <= upperBound;
}
static bool shouldIgnoreRotation(UChar32 character)
{
if (character == 0x000A7 || character == 0x000A9 || character == 0x000AE)
return true;
if (character == 0x000B6 || character == 0x000BC || character == 0x000BD || character == 0x000BE)
return true;
if (isInRange(character, 0x002E5, 0x002EB))
return true;
if (isInRange(character, 0x01100, 0x011FF) || isInRange(character, 0x01401, 0x0167F) || isInRange(character, 0x01800, 0x018FF))
return true;
if (character == 0x02016 || character == 0x02018 || character == 0x02019 || character == 0x02020 || character == 0x02021
|| character == 0x2030 || character == 0x02031)
return true;
if (isInRange(character, 0x0203B, 0x0203D) || character == 0x02042 || character == 0x02044 || character == 0x02047
|| character == 0x02048 || character == 0x02049 || character == 0x2051)
return true;
if (isInRange(character, 0x02065, 0x02069) || isInRange(character, 0x020DD, 0x020E0)
|| isInRange(character, 0x020E2, 0x020E4) || isInRange(character, 0x02100, 0x02117)
|| isInRange(character, 0x02119, 0x02131) || isInRange(character, 0x02133, 0x0213F))
return true;
if (isInRange(character, 0x02145, 0x0214A) || character == 0x0214C || character == 0x0214D
|| isInRange(character, 0x0214F, 0x0218F))
return true;
if (isInRange(character, 0x02300, 0x02307) || isInRange(character, 0x0230C, 0x0231F)
|| isInRange(character, 0x02322, 0x0232B) || isInRange(character, 0x0237D, 0x0239A)
|| isInRange(character, 0x023B4, 0x023B6) || isInRange(character, 0x023BA, 0x023CF)
|| isInRange(character, 0x023D1, 0x023DB) || isInRange(character, 0x023E2, 0x024FF))
return true;
if (isInRange(character, 0x025A0, 0x02619) || isInRange(character, 0x02620, 0x02767)
|| isInRange(character, 0x02776, 0x02793) || isInRange(character, 0x02B12, 0x02B2F)
|| isInRange(character, 0x02B4D, 0x02BFF) || isInRange(character, 0x02E80, 0x03007))
return true;
if (character == 0x03012 || character == 0x03013 || isInRange(character, 0x03020, 0x0302F)
|| isInRange(character, 0x03031, 0x0309F) || isInRange(character, 0x030A1, 0x030FB)
|| isInRange(character, 0x030FD, 0x0A4CF))
return true;
if (isInRange(character, 0x0A840, 0x0A87F) || isInRange(character, 0x0A960, 0x0A97F)
|| isInRange(character, 0x0AC00, 0x0D7FF) || isInRange(character, 0x0E000, 0x0FAFF))
return true;
if (isInRange(character, 0x0FE10, 0x0FE1F) || isInRange(character, 0x0FE30, 0x0FE48)
|| isInRange(character, 0x0FE50, 0x0FE57) || isInRange(character, 0x0FE5F, 0x0FE62)
|| isInRange(character, 0x0FE67, 0x0FE6F))
return true;
if (isInRange(character, 0x0FF01, 0x0FF07) || isInRange(character, 0x0FF0A, 0x0FF0C)
|| isInRange(character, 0x0FF0E, 0x0FF19) || isInRange(character, 0x0FF1F, 0x0FF3A))
return true;
if (character == 0x0FF3C || character == 0x0FF3E)
return true;
if (isInRange(character, 0x0FF40, 0x0FF5A) || isInRange(character, 0x0FFE0, 0x0FFE2)
|| isInRange(character, 0x0FFE4, 0x0FFE7) || isInRange(character, 0x0FFF0, 0x0FFF8)
|| character == 0x0FFFD)
return true;
if (isInRange(character, 0x13000, 0x1342F) || isInRange(character, 0x1B000, 0x1B0FF)
|| isInRange(character, 0x1D000, 0x1D1FF) || isInRange(character, 0x1D300, 0x1D37F)
|| isInRange(character, 0x1F000, 0x1F64F) || isInRange(character, 0x1F680, 0x1F77F))
return true;
if (isInRange(character, 0x20000, 0x2FFFD) || isInRange(character, 0x30000, 0x3FFFD))
return true;
return false;
}
static inline std::pair<GlyphData, GlyphPage*> glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(UChar32 character, NonCJKGlyphOrientation orientation, GlyphData& data, GlyphPage* page, unsigned pageNumber)
{
if (orientation == NonCJKGlyphOrientationUpright || shouldIgnoreRotation(character)) {
RefPtr<SimpleFontData> uprightFontData = data.fontData->uprightOrientationFontData();
GlyphPageTreeNode* uprightNode = GlyphPageTreeNode::getRootChild(uprightFontData.get(), pageNumber);
GlyphPage* uprightPage = uprightNode->page();
if (uprightPage) {
GlyphData uprightData = uprightPage->glyphDataForCharacter(character);
// If the glyphs are the same, then we know we can just use the horizontal glyph rotated vertically to be upright.
if (data.glyph == uprightData.glyph)
return std::make_pair(data, page);
// The glyphs are distinct, meaning that the font has a vertical-right glyph baked into it. We can't use that
// glyph, so we fall back to the upright data and use the horizontal glyph.
if (uprightData.fontData)
return std::make_pair(uprightData, uprightPage);
}
} else if (orientation == NonCJKGlyphOrientationVerticalRight) {
RefPtr<SimpleFontData> verticalRightFontData = data.fontData->verticalRightOrientationFontData();
GlyphPageTreeNode* verticalRightNode = GlyphPageTreeNode::getRootChild(verticalRightFontData.get(), pageNumber);
GlyphPage* verticalRightPage = verticalRightNode->page();
if (verticalRightPage) {
GlyphData verticalRightData = verticalRightPage->glyphDataForCharacter(character);
// If the glyphs are distinct, we will make the assumption that the font has a vertical-right glyph baked
// into it.
if (data.glyph != verticalRightData.glyph)
return std::make_pair(data, page);
// The glyphs are identical, meaning that we should just use the horizontal glyph.
if (verticalRightData.fontData)
return std::make_pair(verticalRightData, verticalRightPage);
}
}
return std::make_pair(data, page);
}
std::pair<GlyphData, GlyphPage*> Font::glyphDataAndPageForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
{
ASSERT(isMainThread());
if (variant == AutoVariant) {
if (m_fontDescription.variant() == FontVariantSmallCaps && !primaryFont()->isSVGFont()) {
UChar32 upperC = toUpper(c);
if (upperC != c) {
c = upperC;
variant = SmallCapsVariant;
} else {
variant = NormalVariant;
}
} else {
variant = NormalVariant;
}
}
if (mirror)
c = mirroredChar(c);
unsigned pageNumber = (c / GlyphPage::size);
GlyphPageTreeNode* node = m_fontFallbackList->getPageNode(pageNumber);
if (!node) {
node = GlyphPageTreeNode::getRootChild(fontDataAt(0), pageNumber);
m_fontFallbackList->setPageNode(pageNumber, node);
}
GlyphPage* page = 0;
if (variant == NormalVariant) {
// Fastest loop, for the common case (normal variant).
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData && (data.fontData->platformData().orientation() == Horizontal || data.fontData->isTextOrientationFallback()))
return std::make_pair(data, page);
if (data.fontData) {
if (Character::isCJKIdeographOrSymbol(c)) {
if (!data.fontData->hasVerticalGlyphs()) {
// Use the broken ideograph font data. The broken ideograph font will use the horizontal width of glyphs
// to make sure you get a square (even for broken glyphs like symbols used for punctuation).
variant = BrokenIdeographVariant;
break;
}
} else {
return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, page, pageNumber);
}
return std::make_pair(data, page);
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
m_fontFallbackList->setPageNode(pageNumber, node);
}
}
if (variant != NormalVariant) {
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData) {
// The variantFontData function should not normally return 0.
// But if it does, we will just render the capital letter big.
RefPtr<SimpleFontData> variantFontData = data.fontData->variantFontData(m_fontDescription, variant);
if (!variantFontData)
return std::make_pair(data, page);
GlyphPageTreeNode* variantNode = GlyphPageTreeNode::getRootChild(variantFontData.get(), pageNumber);
GlyphPage* variantPage = variantNode->page();
if (variantPage) {
GlyphData data = variantPage->glyphDataForCharacter(c);
if (data.fontData)
return std::make_pair(data, variantPage);
}
// Do not attempt system fallback off the variantFontData. This is the very unlikely case that
// a font has the lowercase character but the small caps font does not have its uppercase version.
return std::make_pair(variantFontData->missingGlyphData(), page);
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
m_fontFallbackList->setPageNode(pageNumber, node);
}
}
ASSERT(page);
ASSERT(node->isSystemFallback());
// System fallback is character-dependent. When we get here, we
// know that the character in question isn't in the system fallback
// font's glyph page. Try to lazily create it here.
// FIXME: Unclear if this should normalizeSpaces above 0xFFFF.
// Doing so changes fast/text/international/plane2-diffs.html
UChar32 characterToRender = c;
if (characterToRender <= 0xFFFF)
characterToRender = Character::normalizeSpaces(characterToRender);
const SimpleFontData* fontDataToSubstitute = fontDataAt(0)->fontDataForCharacter(characterToRender);
RefPtr<SimpleFontData> characterFontData = FontCache::fontCache()->fallbackFontForCharacter(m_fontDescription, characterToRender, fontDataToSubstitute);
if (characterFontData) {
if (characterFontData->platformData().orientation() == Vertical && !characterFontData->hasVerticalGlyphs() && Character::isCJKIdeographOrSymbol(c))
variant = BrokenIdeographVariant;
if (variant != NormalVariant)
characterFontData = characterFontData->variantFontData(m_fontDescription, variant);
}
if (characterFontData) {
// Got the fallback glyph and font.
GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData.get(), pageNumber)->page();
GlyphData data = fallbackPage && fallbackPage->glyphForCharacter(c) ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
// Cache it so we don't have to do system fallback again next time.
if (variant == NormalVariant) {
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
if (!Character::isCJKIdeographOrSymbol(c) && data.fontData->platformData().orientation() != Horizontal && !data.fontData->isTextOrientationFallback())
return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, page, pageNumber);
}
return std::make_pair(data, page);
}
// Even system fallback can fail; use the missing glyph in that case.
// FIXME: It would be nicer to use the missing glyph from the last resort font instead.
GlyphData data = primaryFont()->missingGlyphData();
if (variant == NormalVariant) {
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
}
return std::make_pair(data, page);
}
bool Font::primaryFontHasGlyphForCharacter(UChar32 character) const
{
unsigned pageNumber = (character / GlyphPage::size);
GlyphPageTreeNode* node = GlyphPageTreeNode::getRootChild(primaryFont(), pageNumber);
GlyphPage* page = node->page();
return page && page->glyphForCharacter(character);
}
// FIXME: This function may not work if the emphasis mark uses a complex script, but none of the
// standard emphasis marks do so.
bool Font::getEmphasisMarkGlyphData(const AtomicString& mark, GlyphData& glyphData) const
{
if (mark.isEmpty())
return false;
UChar32 character = mark[0];
if (U16_IS_SURROGATE(character)) {
if (!U16_IS_SURROGATE_LEAD(character))
return false;
if (mark.length() < 2)
return false;
UChar low = mark[1];
if (!U16_IS_TRAIL(low))
return false;
character = U16_GET_SUPPLEMENTARY(character, low);
}
glyphData = glyphDataForCharacter(character, false, EmphasisMarkVariant);
return true;
}
int Font::emphasisMarkAscent(const AtomicString& mark) const
{
FontCachePurgePreventer purgePreventer;
GlyphData markGlyphData;
if (!getEmphasisMarkGlyphData(mark, markGlyphData))
return 0;
const SimpleFontData* markFontData = markGlyphData.fontData;
ASSERT(markFontData);
if (!markFontData)
return 0;
return markFontData->fontMetrics().ascent();
}
int Font::emphasisMarkDescent(const AtomicString& mark) const
{
FontCachePurgePreventer purgePreventer;
GlyphData markGlyphData;
if (!getEmphasisMarkGlyphData(mark, markGlyphData))
return 0;
const SimpleFontData* markFontData = markGlyphData.fontData;
ASSERT(markFontData);
if (!markFontData)
return 0;
return markFontData->fontMetrics().descent();
}
int Font::emphasisMarkHeight(const AtomicString& mark) const
{
FontCachePurgePreventer purgePreventer;
GlyphData markGlyphData;
if (!getEmphasisMarkGlyphData(mark, markGlyphData))
return 0;
const SimpleFontData* markFontData = markGlyphData.fontData;
ASSERT(markFontData);
if (!markFontData)
return 0;
return markFontData->fontMetrics().height();
}
float Font::drawGlyphBuffer(GraphicsContext* context, const TextRunPaintInfo& runInfo, const GlyphBuffer& glyphBuffer, const FloatPoint& point) const
{
// Draw each contiguous run of glyphs that use the same font data.
const SimpleFontData* fontData = glyphBuffer.fontDataAt(0);
FloatPoint startPoint(point);
float advanceSoFar = 0;
unsigned lastFrom = 0;
unsigned nextGlyph = 0;
while (nextGlyph < glyphBuffer.size()) {
const SimpleFontData* nextFontData = glyphBuffer.fontDataAt(nextGlyph);
if (nextFontData != fontData) {
drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint, runInfo.bounds);
lastFrom = nextGlyph;
fontData = nextFontData;
startPoint += FloatSize(advanceSoFar, 0);
advanceSoFar = 0;
}
advanceSoFar += glyphBuffer.advanceAt(nextGlyph);
nextGlyph++;
}
drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint, runInfo.bounds);
startPoint += FloatSize(advanceSoFar, 0);
return startPoint.x() - point.x();
}
inline static float offsetToMiddleOfGlyph(const SimpleFontData* fontData, Glyph glyph)
{
if (fontData->platformData().orientation() == Horizontal) {
FloatRect bounds = fontData->boundsForGlyph(glyph);
return bounds.x() + bounds.width() / 2;
}
// FIXME: Use glyph bounds once they make sense for vertical fonts.
return fontData->widthForGlyph(glyph) / 2;
}
inline static float offsetToMiddleOfAdvanceAtIndex(const GlyphBuffer& glyphBuffer, size_t i)
{
return glyphBuffer.advanceAt(i) / 2;
}
void Font::drawEmphasisMarks(GraphicsContext* context, const TextRunPaintInfo& runInfo, const GlyphBuffer& glyphBuffer, const AtomicString& mark, const FloatPoint& point) const
{
FontCachePurgePreventer purgePreventer;
GlyphData markGlyphData;
if (!getEmphasisMarkGlyphData(mark, markGlyphData))
return;
const SimpleFontData* markFontData = markGlyphData.fontData;
ASSERT(markFontData);
if (!markFontData)
return;
Glyph markGlyph = markGlyphData.glyph;
Glyph spaceGlyph = markFontData->spaceGlyph();
float middleOfLastGlyph = offsetToMiddleOfAdvanceAtIndex(glyphBuffer, 0);
FloatPoint startPoint(point.x() + middleOfLastGlyph - offsetToMiddleOfGlyph(markFontData, markGlyph), point.y());
GlyphBuffer markBuffer;
for (unsigned i = 0; i + 1 < glyphBuffer.size(); ++i) {
float middleOfNextGlyph = offsetToMiddleOfAdvanceAtIndex(glyphBuffer, i + 1);
float advance = glyphBuffer.advanceAt(i) - middleOfLastGlyph + middleOfNextGlyph;
markBuffer.add(glyphBuffer.glyphAt(i) ? markGlyph : spaceGlyph, markFontData, advance);
middleOfLastGlyph = middleOfNextGlyph;
}
markBuffer.add(glyphBuffer.glyphAt(glyphBuffer.size() - 1) ? markGlyph : spaceGlyph, markFontData, 0);
drawGlyphBuffer(context, runInfo, markBuffer, startPoint);
}
float Font::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, IntRectExtent* glyphBounds) const
{
WidthIterator it(this, run, fallbackFonts, glyphBounds);
it.advance(run.length());
if (glyphBounds) {
glyphBounds->setTop(floorf(-it.minGlyphBoundingBoxY()));
glyphBounds->setBottom(ceilf(it.maxGlyphBoundingBoxY()));
glyphBounds->setLeft(floorf(it.firstGlyphOverflow()));
glyphBounds->setRight(ceilf(it.lastGlyphOverflow()));
}
return it.m_runWidthSoFar;
}
FloatRect Font::pixelSnappedSelectionRect(float fromX, float toX, float y, float height)
{
// Using roundf() rather than ceilf() for the right edge as a compromise to
// ensure correct caret positioning.
float roundedX = roundf(fromX);
return FloatRect(roundedX, y, roundf(toX - roundedX), height);
}
FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FloatPoint& point, int h, int from, int to, bool accountForGlyphBounds) const
{
WidthIterator it(this, run, 0, accountForGlyphBounds);
it.advance(from);
float fromX = it.m_runWidthSoFar;
it.advance(to);
float toX = it.m_runWidthSoFar;
if (run.rtl()) {
it.advance(run.length());
float totalWidth = it.m_runWidthSoFar;
float beforeWidth = fromX;
float afterWidth = toX;
fromX = totalWidth - afterWidth;
toX = totalWidth - beforeWidth;
}
return pixelSnappedSelectionRect(point.x() + fromX, point.x() + toX,
accountForGlyphBounds ? it.minGlyphBoundingBoxY() : point.y(),
accountForGlyphBounds ? it.maxGlyphBoundingBoxY() - it.minGlyphBoundingBoxY() : h);
}
int Font::offsetForPositionForSimpleText(const TextRun& run, float x, bool includePartialGlyphs) const
{
float delta = x;
WidthIterator it(this, run);
unsigned offset;
if (run.rtl()) {
delta -= floatWidthForSimpleText(run);
while (1) {
offset = it.m_currentCharacter;
float w;
if (!it.advanceOneCharacter(w))
break;
delta += w;
if (includePartialGlyphs) {
if (delta - w / 2 >= 0)
break;
} else {
if (delta >= 0)
break;
}
}
} else {
while (1) {
offset = it.m_currentCharacter;
float w;
if (!it.advanceOneCharacter(w))
break;
delta -= w;
if (includePartialGlyphs) {
if (delta + w / 2 <= 0)
break;
} else {
if (delta <= 0)
break;
}
}
}
return offset;
}
} // namespace blink
Reference in New Issue View Git Blame Copy Permalink