SimpleFontDataFreeType.cpp [plain text]
#include "config.h"
#include "SimpleFontData.h"
#include "FloatConversion.h"
#include "FloatRect.h"
#include "Font.h"
#include "FontCache.h"
#include "FontDescription.h"
#include "GlyphBuffer.h"
#include "OpenTypeTypes.h"
#include "UTF16UChar32Iterator.h"
#include <cairo-ft.h>
#include <cairo.h>
#include <fontconfig/fcfreetype.h>
#include <ft2build.h>
#include FT_TRUETYPE_TABLES_H
#include FT_TRUETYPE_TAGS_H
#include <unicode/normlzr.h>
#include <wtf/MathExtras.h>
namespace WebCore {
void SimpleFontData::platformInit()
{
if (!m_platformData.m_size)
return;
ASSERT(m_platformData.scaledFont());
cairo_font_extents_t fontExtents;
cairo_scaled_font_extents(m_platformData.scaledFont(), &fontExtents);
float ascent = narrowPrecisionToFloat(fontExtents.ascent);
float descent = narrowPrecisionToFloat(fontExtents.descent);
float lineGap = narrowPrecisionToFloat(fontExtents.height - fontExtents.ascent - fontExtents.descent);
m_fontMetrics.setAscent(ascent);
m_fontMetrics.setDescent(descent);
#if PLATFORM(EFL)
m_fontMetrics.setLineSpacing(ascent + descent + lineGap);
#else
m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
#endif
m_fontMetrics.setLineGap(lineGap);
cairo_text_extents_t textExtents;
cairo_scaled_font_text_extents(m_platformData.scaledFont(), "x", &textExtents);
m_fontMetrics.setXHeight(narrowPrecisionToFloat((platformData().orientation() == Horizontal) ? textExtents.height : textExtents.width));
cairo_scaled_font_text_extents(m_platformData.scaledFont(), " ", &textExtents);
m_spaceWidth = narrowPrecisionToFloat((platformData().orientation() == Horizontal) ? textExtents.x_advance : -textExtents.y_advance);
if ((platformData().orientation() == Vertical) && !isTextOrientationFallback()) {
FT_Face freeTypeFace = cairo_ft_scaled_font_lock_face(m_platformData.scaledFont());
m_fontMetrics.setUnitsPerEm(freeTypeFace->units_per_EM);
cairo_ft_scaled_font_unlock_face(m_platformData.scaledFont());
}
m_syntheticBoldOffset = m_platformData.syntheticBold() ? 1.0f : 0.f;
}
void SimpleFontData::platformCharWidthInit()
{
m_avgCharWidth = 0.f;
m_maxCharWidth = 0.f;
initCharWidths();
}
void SimpleFontData::platformDestroy()
{
}
PassRefPtr<SimpleFontData> SimpleFontData::platformCreateScaledFontData(const FontDescription& fontDescription, float scaleFactor) const
{
ASSERT(m_platformData.scaledFont());
return SimpleFontData::create(FontPlatformData(cairo_scaled_font_get_font_face(m_platformData.scaledFont()),
scaleFactor * fontDescription.computedSize(),
m_platformData.syntheticBold(),
m_platformData.syntheticOblique(),
fontDescription.orientation()),
isCustomFont(), false);
}
bool SimpleFontData::containsCharacters(const UChar* characters, int bufferLength) const
{
ASSERT(m_platformData.scaledFont());
FT_Face face = cairo_ft_scaled_font_lock_face(m_platformData.scaledFont());
if (!face)
return false;
UTF16UChar32Iterator iterator(characters, bufferLength);
UChar32 character = iterator.next();
while (character != iterator.end()) {
if (!FcFreeTypeCharIndex(face, character)) {
cairo_ft_scaled_font_unlock_face(m_platformData.scaledFont());
return false;
}
character = iterator.next();
}
cairo_ft_scaled_font_unlock_face(m_platformData.scaledFont());
return true;
}
void SimpleFontData::determinePitch()
{
m_treatAsFixedPitch = m_platformData.isFixedPitch();
}
FloatRect SimpleFontData::platformBoundsForGlyph(Glyph glyph) const
{
if (!m_platformData.size())
return FloatRect();
cairo_glyph_t cglyph = { glyph, 0, 0 };
cairo_text_extents_t extents;
cairo_scaled_font_glyph_extents(m_platformData.scaledFont(), &cglyph, 1, &extents);
if (cairo_scaled_font_status(m_platformData.scaledFont()) == CAIRO_STATUS_SUCCESS)
return FloatRect(extents.x_bearing, extents.y_bearing, extents.width, extents.height);
return FloatRect();
}
float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
{
if (!m_platformData.size())
return 0;
if (cairo_scaled_font_status(m_platformData.scaledFont()) != CAIRO_STATUS_SUCCESS)
return m_spaceWidth;
cairo_glyph_t cairoGlyph = { glyph, 0, 0 };
cairo_text_extents_t extents;
cairo_scaled_font_glyph_extents(m_platformData.scaledFont(), &cairoGlyph, 1, &extents);
float width = platformData().orientation() == Horizontal ? extents.x_advance : -extents.y_advance;
return width ? width : m_spaceWidth;
}
#if USE(HARFBUZZ)
bool SimpleFontData::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
{
if (!m_combiningCharacterSequenceSupport)
m_combiningCharacterSequenceSupport = adoptPtr(new HashMap<String, bool>);
WTF::HashMap<String, bool>::AddResult addResult = m_combiningCharacterSequenceSupport->add(String(characters, length), false);
if (!addResult.isNewEntry)
return addResult.iterator->value;
UErrorCode error = U_ZERO_ERROR;
Vector<UChar, 4> normalizedCharacters(length);
int32_t normalizedLength = unorm_normalize(characters, length, UNORM_NFC, UNORM_UNICODE_3_2, &normalizedCharacters[0], length, &error);
if (U_FAILURE(error) || (static_cast<size_t>(normalizedLength) == length))
return false;
FT_Face face = cairo_ft_scaled_font_lock_face(m_platformData.scaledFont());
if (!face)
return false;
if (FcFreeTypeCharIndex(face, normalizedCharacters[0]))
addResult.iterator->value = true;
cairo_ft_scaled_font_unlock_face(m_platformData.scaledFont());
return addResult.iterator->value;
}
#endif
}