#include "config.h"
#include "Font.h"
#include "FloatRect.h"
#include "FontCache.h"
#include "FontTranscoder.h"
#if PLATFORM(QT) && HAVE(QRAWFONT)
#include "GraphicsContext.h"
#endif
#include "IntPoint.h"
#include "GlyphBuffer.h"
#include "TextRun.h"
#include "WidthIterator.h"
#include <wtf/MathExtras.h>
#include <wtf/UnusedParam.h>
using namespace WTF;
using namespace Unicode;
namespace WebCore {
Font::CodePath Font::s_codePath = Auto;
Font::Font()
: m_letterSpacing(0)
, m_wordSpacing(0)
, m_isPlatformFont(false)
, m_needsTranscoding(false)
{
}
Font::Font(const FontDescription& fd, short letterSpacing, short wordSpacing)
: m_fontDescription(fd)
, m_letterSpacing(letterSpacing)
, m_wordSpacing(wordSpacing)
, m_isPlatformFont(false)
, m_needsTranscoding(fontTranscoder().needsTranscoding(fd))
{
}
Font::Font(const FontPlatformData& fontData, bool isPrinterFont, FontSmoothingMode fontSmoothingMode)
: m_fontList(FontFallbackList::create())
, m_letterSpacing(0)
, m_wordSpacing(0)
, m_isPlatformFont(true)
{
m_fontDescription.setUsePrinterFont(isPrinterFont);
m_fontDescription.setFontSmoothing(fontSmoothingMode);
m_needsTranscoding = fontTranscoder().needsTranscoding(fontDescription());
m_fontList->setPlatformFont(fontData);
}
Font::Font(const Font& other)
: m_fontDescription(other.m_fontDescription)
, m_fontList(other.m_fontList)
, m_letterSpacing(other.m_letterSpacing)
, m_wordSpacing(other.m_wordSpacing)
, m_isPlatformFont(other.m_isPlatformFont)
, m_needsTranscoding(fontTranscoder().needsTranscoding(other.m_fontDescription))
{
}
Font& Font::operator=(const Font& other)
{
m_fontDescription = other.m_fontDescription;
m_fontList = other.m_fontList;
m_letterSpacing = other.m_letterSpacing;
m_wordSpacing = other.m_wordSpacing;
m_isPlatformFont = other.m_isPlatformFont;
m_needsTranscoding = other.m_needsTranscoding;
return *this;
}
bool Font::operator==(const Font& other) const
{
if (loadingCustomFonts() || other.loadingCustomFonts())
return false;
FontSelector* first = m_fontList ? m_fontList->fontSelector() : 0;
FontSelector* second = other.m_fontList ? other.m_fontList->fontSelector() : 0;
return first == second
&& m_fontDescription == other.m_fontDescription
&& m_letterSpacing == other.m_letterSpacing
&& m_wordSpacing == other.m_wordSpacing
&& (m_fontList ? m_fontList->generation() : 0) == (other.m_fontList ? other.m_fontList->generation() : 0);
}
void Font::update(PassRefPtr<FontSelector> fontSelector) const
{
if (!m_fontList)
m_fontList = FontFallbackList::create();
m_fontList->invalidate(fontSelector);
}
void Font::drawText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
{
if (loadingCustomFonts())
return;
to = (to == -1 ? run.length() : to);
#if ENABLE(SVG_FONTS)
if (primaryFont()->isSVGFont()) {
drawTextUsingSVGFont(context, run, point, from, to);
return;
}
#endif
CodePath codePathToUse = codePath(run);
#if PLATFORM(QT) && HAVE(QRAWFONT)
if (context->textDrawingMode() & TextModeStroke)
codePathToUse = Complex;
#endif
if (codePathToUse != Complex)
return drawSimpleText(context, run, point, from, to);
return drawComplexText(context, run, point, from, to);
}
void Font::drawEmphasisMarks(GraphicsContext* context, const TextRun& run, const AtomicString& mark, const FloatPoint& point, int from, int to) const
{
if (loadingCustomFonts())
return;
if (to < 0)
to = run.length();
#if ENABLE(SVG_FONTS)
if (primaryFont()->isSVGFont())
return;
#endif
if (codePath(run) != Complex)
drawEmphasisMarksForSimpleText(context, run, mark, point, from, to);
else
drawEmphasisMarksForComplexText(context, run, mark, point, from, to);
}
float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
{
#if ENABLE(SVG_FONTS)
if (primaryFont()->isSVGFont())
return floatWidthUsingSVGFont(run);
#endif
CodePath codePathToUse = codePath(run);
if (codePathToUse != Complex) {
static bool returnFallbackFonts = canReturnFallbackFontsForComplexText();
return floatWidthForSimpleText(run, 0, returnFallbackFonts ? fallbackFonts : 0, codePathToUse == SimpleWithGlyphOverflow || (glyphOverflow && glyphOverflow->computeBounds) ? glyphOverflow : 0);
}
return floatWidthForComplexText(run, fallbackFonts, glyphOverflow);
}
float Font::width(const TextRun& run, int extraCharsAvailable, int& charsConsumed, String& glyphName) const
{
#if !ENABLE(SVG_FONTS)
UNUSED_PARAM(extraCharsAvailable);
#else
if (primaryFont()->isSVGFont())
return floatWidthUsingSVGFont(run, extraCharsAvailable, charsConsumed, glyphName);
#endif
charsConsumed = run.length();
glyphName = "";
if (codePath(run) != Complex)
return floatWidthForSimpleText(run, 0);
return floatWidthForComplexText(run);
}
FloatRect Font::selectionRectForText(const TextRun& run, const FloatPoint& point, int h, int from, int to) const
{
#if ENABLE(SVG_FONTS)
if (primaryFont()->isSVGFont())
return selectionRectForTextUsingSVGFont(run, point, h, from, to);
#endif
to = (to == -1 ? run.length() : to);
if (codePath(run) != Complex)
return selectionRectForSimpleText(run, point, h, from, to);
return selectionRectForComplexText(run, point, h, from, to);
}
int Font::offsetForPosition(const TextRun& run, float x, bool includePartialGlyphs) const
{
#if ENABLE(SVG_FONTS)
if (primaryFont()->isSVGFont())
return offsetForPositionForTextUsingSVGFont(run, x, includePartialGlyphs);
#endif
if (codePath(run) != Complex)
return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
return offsetForPositionForComplexText(run, x, includePartialGlyphs);
}
#if ENABLE(SVG_FONTS)
bool Font::isSVGFont() const
{
return primaryFont()->isSVGFont();
}
#endif
String Font::normalizeSpaces(const UChar* characters, unsigned length)
{
UChar* buffer;
String normalized = String::createUninitialized(length, buffer);
for (unsigned i = 0; i < length; ++i)
buffer[i] = normalizeSpaces(characters[i]);
return normalized;
}
static bool shouldUseFontSmoothing = true;
void Font::setShouldUseSmoothing(bool shouldUseSmoothing)
{
ASSERT(isMainThread());
shouldUseFontSmoothing = shouldUseSmoothing;
}
bool Font::shouldUseSmoothing()
{
return shouldUseFontSmoothing;
}
void Font::setCodePath(CodePath p)
{
s_codePath = p;
}
Font::CodePath Font::codePath()
{
return s_codePath;
}
Font::CodePath Font::codePath(const TextRun& run) const
{
if (s_codePath != Auto)
return s_codePath;
#if PLATFORM(QT) && !HAVE(QRAWFONT)
if (run.expansion() || run.rtl() || isSmallCaps() || wordSpacing() || letterSpacing())
return Complex;
#endif
CodePath result = Simple;
for (int i = 0; i < run.length(); i++) {
const UChar c = run[i];
if (c < 0x2E5) continue;
if (c <= 0x2E9)
return Complex;
if (c < 0x300) continue;
if (c <= 0x36F)
return Complex;
if (c < 0x0591 || c == 0x05BE) continue;
if (c <= 0x05CF)
return Complex;
if (c < 0x0600)
continue;
if (c <= 0x109F)
return Complex;
if (c < 0x1100)
continue;
if (c <= 0x11FF)
return Complex;
if (c < 0x135D) continue;
if (c <= 0x135F)
return Complex;
if (c < 0x1700) continue;
if (c <= 0x18AF)
return Complex;
if (c < 0x1900) continue;
if (c <= 0x194F)
return Complex;
if (c < 0x1980) continue;
if (c <= 0x19DF)
return Complex;
if (c < 0x1A00) continue;
if (c <= 0x1CFF)
return Complex;
if (c < 0x1DC0) continue;
if (c <= 0x1DFF)
return Complex;
if (c <= 0x2000) {
result = SimpleWithGlyphOverflow;
continue;
}
if (c < 0x20D0) continue;
if (c <= 0x20FF)
return Complex;
if (c < 0x2CEF) continue;
if (c <= 0x2CF1)
return Complex;
if (c < 0x302A) continue;
if (c <= 0x302F)
return Complex;
if (c < 0xA67C) continue;
if (c <= 0xA67D)
return Complex;
if (c < 0xA6F0) continue;
if (c <= 0xA6F1)
return Complex;
if (c < 0xA800)
continue;
if (c <= 0xABFF)
return Complex;
if (c < 0xD7B0) continue;
if (c <= 0xD7FF)
return Complex;
if (c < 0xFE20) continue;
if (c <= 0xFE2F)
return Complex;
}
if (typesettingFeatures())
return Complex;
return result;
}
bool Font::isCJKIdeograph(UChar32 c)
{
if (c >= 0x4E00 && c <= 0x9FFF)
return true;
if (c >= 0x3400 && c <= 0x4DBF)
return true;
if (c >= 0x2E80 && c <= 0x2EFF)
return true;
if (c >= 0x2F00 && c <= 0x2FDF)
return true;
if (c >= 0x31C0 && c <= 0x31EF)
return true;
if (c >= 0xF900 && c <= 0xFAFF)
return true;
if (c >= 0x20000 && c <= 0x2A6DF)
return true;
if (c >= 0x2A700 && c <= 0x2B73F)
return true;
if (c >= 0x2B740 && c <= 0x2B81F)
return true;
if (c >= 0x2F800 && c <= 0x2FA1F)
return true;
return false;
}
bool Font::isCJKIdeographOrSymbol(UChar32 c)
{
if ((c == 0x2C7) || (c == 0x2CA) || (c == 0x2CB) || (c == 0x2D9))
return true;
if (c >= 0x2FF0 && c <= 0x2FFF)
return true;
if (c >= 0x3000 && c <= 0x303F)
return true;
if (c >= 0x3040 && c <= 0x309F)
return true;
if (c >= 0x30A0 && c <= 0x30FF)
return true;
if (c >= 0x3100 && c <= 0x312F)
return true;
if (c >= 0x31A0 && c <= 0x31BF)
return true;
if (c >= 0x3200 && c <= 0x32FF)
return true;
if (c >= 0x3300 && c <= 0x33FF)
return true;
if (c >= 0xFE30 && c <= 0xFE4F)
return true;
if (c >= 0xFF00 && c <= 0xFFEF)
return true;
if (c >= 0x1F200 && c <= 0x1F6F)
return true;
return isCJKIdeograph(c);
}
unsigned Font::expansionOpportunityCount(const UChar* characters, size_t length, TextDirection direction, bool& isAfterExpansion)
{
static bool expandAroundIdeographs = canExpandAroundIdeographsInComplexText();
unsigned count = 0;
if (direction == LTR) {
for (size_t i = 0; i < length; ++i) {
UChar32 character = characters[i];
if (treatAsSpace(character)) {
count++;
isAfterExpansion = true;
continue;
}
if (U16_IS_LEAD(character) && i + 1 < length && U16_IS_TRAIL(characters[i + 1])) {
character = U16_GET_SUPPLEMENTARY(character, characters[i + 1]);
i++;
}
if (expandAroundIdeographs && isCJKIdeographOrSymbol(character)) {
if (!isAfterExpansion)
count++;
count++;
isAfterExpansion = true;
continue;
}
isAfterExpansion = false;
}
} else {
for (size_t i = length; i > 0; --i) {
UChar32 character = characters[i - 1];
if (treatAsSpace(character)) {
count++;
isAfterExpansion = true;
continue;
}
if (U16_IS_TRAIL(character) && i > 1 && U16_IS_LEAD(characters[i - 2])) {
character = U16_GET_SUPPLEMENTARY(characters[i - 2], character);
i--;
}
if (expandAroundIdeographs && isCJKIdeographOrSymbol(character)) {
if (!isAfterExpansion)
count++;
count++;
isAfterExpansion = true;
continue;
}
isAfterExpansion = false;
}
}
return count;
}
bool Font::canReceiveTextEmphasis(UChar32 c)
{
CharCategory category = Unicode::category(c);
if (category & (Separator_Space | Separator_Line | Separator_Paragraph | Other_NotAssigned | Other_Control | Other_Format))
return false;
if (c == ethiopicWordspace || c == aegeanWordSeparatorLine || c == aegeanWordSeparatorDot
|| c == ugariticWordDivider || c == tibetanMarkIntersyllabicTsheg || c == tibetanMarkDelimiterTshegBstar)
return false;
return true;
}
}