blob: e02fced74f9aada673784eb32e6060d08719ea82 [file] [log] [blame]
/*
* Copyright (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
* Copyright (C) Research In Motion Limited 2010. 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 "config.h"
#if ENABLE(SVG_FONTS)
#include "Font.h"
#include "CSSFontSelector.h"
#include "GraphicsContext.h"
#include "RenderObject.h"
#include "RenderSVGInlineText.h"
#include "RenderSVGResourceSolidColor.h"
#include "SVGAltGlyphElement.h"
#include "SVGFontData.h"
#include "SVGFontElement.h"
#include "SVGFontFaceElement.h"
#include "SVGGlyphElement.h"
#include "SVGGlyphMap.h"
#include "SVGMissingGlyphElement.h"
#include "SVGNames.h"
#include "SimpleFontData.h"
#include "TextRun.h"
#include "XMLNames.h"
using namespace WTF::Unicode;
namespace WebCore {
static inline float convertEmUnitToPixel(float fontSize, float unitsPerEm, float value)
{
if (!unitsPerEm)
return 0.0f;
return value * fontSize / unitsPerEm;
}
static inline bool isVerticalWritingMode(const SVGRenderStyle* style)
{
return style->writingMode() == WM_TBRL || style->writingMode() == WM_TB;
}
// Helper functions to determine the arabic character forms (initial, medial, terminal, isolated)
enum ArabicCharShapingMode {
SNone = 0,
SRight = 1,
SDual = 2
};
static const ArabicCharShapingMode s_arabicCharShapingMode[222] = {
SRight, SRight, SRight, SRight, SDual , SRight, SDual , SRight, SDual , SDual , SDual , SDual , SDual , SRight, /* 0x0622 - 0x062F */
SRight, SRight, SRight, SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SNone , SNone , SNone , SNone , SNone , /* 0x0630 - 0x063F */
SNone , SDual , SDual , SDual , SDual , SDual , SDual , SRight, SDual , SDual , SNone , SNone , SNone , SNone , SNone , SNone , /* 0x0640 - 0x064F */
SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , /* 0x0650 - 0x065F */
SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , /* 0x0660 - 0x066F */
SNone , SRight, SRight, SRight, SNone , SRight, SRight, SRight, SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , /* 0x0670 - 0x067F */
SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SRight, SRight, SRight, SRight, SRight, SRight, SRight, SRight, /* 0x0680 - 0x068F */
SRight, SRight, SRight, SRight, SRight, SRight, SRight, SRight, SRight, SRight, SDual , SDual , SDual , SDual , SDual , SDual , /* 0x0690 - 0x069F */
SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , /* 0x06A0 - 0x06AF */
SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , SDual , /* 0x06B0 - 0x06BF */
SRight, SDual , SRight, SRight, SRight, SRight, SRight, SRight, SRight, SRight, SRight, SRight, SDual , SRight, SDual , SRight, /* 0x06C0 - 0x06CF */
SDual , SDual , SRight, SRight, SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , /* 0x06D0 - 0x06DF */
SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , /* 0x06E0 - 0x06EF */
SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SNone , SDual , SDual , SDual , SNone , SNone , SNone /* 0x06F0 - 0x06FF */
};
static inline SVGGlyphIdentifier::ArabicForm processArabicFormDetection(const UChar& curChar, bool& lastCharShapesRight, SVGGlyphIdentifier::ArabicForm* prevForm)
{
SVGGlyphIdentifier::ArabicForm curForm;
ArabicCharShapingMode shapingMode = SNone;
if (curChar >= 0x0622 && curChar <= 0x06FF)
shapingMode = s_arabicCharShapingMode[curChar - 0x0622];
// Use a simple state machine to identify the actual arabic form
// It depends on the order of the arabic form enum:
// enum ArabicForm { None = 0, Isolated, Terminal, Initial, Medial };
if (lastCharShapesRight && shapingMode == SDual) {
if (prevForm) {
int correctedForm = (int) *prevForm + 1;
ASSERT(correctedForm >= SVGGlyphIdentifier::None && correctedForm <= SVGGlyphIdentifier::Medial);
*prevForm = static_cast<SVGGlyphIdentifier::ArabicForm>(correctedForm);
}
curForm = SVGGlyphIdentifier::Initial;
} else
curForm = shapingMode == SNone ? SVGGlyphIdentifier::None : SVGGlyphIdentifier::Isolated;
lastCharShapesRight = shapingMode != SNone;
return curForm;
}
static Vector<SVGGlyphIdentifier::ArabicForm> charactersWithArabicForm(const String& input, bool rtl)
{
Vector<SVGGlyphIdentifier::ArabicForm> forms;
unsigned length = input.length();
bool containsArabic = false;
for (unsigned i = 0; i < length; ++i) {
if (isArabicChar(input[i])) {
containsArabic = true;
break;
}
}
if (!containsArabic)
return forms;
bool lastCharShapesRight = false;
// Start identifying arabic forms
if (rtl) {
for (int i = length - 1; i >= 0; --i)
forms.prepend(processArabicFormDetection(input[i], lastCharShapesRight, forms.isEmpty() ? 0 : &forms.first()));
} else {
for (unsigned i = 0; i < length; ++i)
forms.append(processArabicFormDetection(input[i], lastCharShapesRight, forms.isEmpty() ? 0 : &forms.last()));
}
return forms;
}
static inline bool isCompatibleArabicForm(const SVGGlyphIdentifier& identifier, const Vector<SVGGlyphIdentifier::ArabicForm>& chars, unsigned startPosition, unsigned endPosition)
{
if (chars.isEmpty())
return true;
Vector<SVGGlyphIdentifier::ArabicForm>::const_iterator it = chars.begin() + startPosition;
Vector<SVGGlyphIdentifier::ArabicForm>::const_iterator end = chars.begin() + endPosition;
ASSERT(end <= chars.end());
for (; it != end; ++it) {
if (*it != static_cast<SVGGlyphIdentifier::ArabicForm>(identifier.arabicForm) && *it != SVGGlyphIdentifier::None)
return false;
}
return true;
}
static inline bool isCompatibleGlyph(const SVGGlyphIdentifier& identifier, bool isVerticalText, const String& language,
const Vector<SVGGlyphIdentifier::ArabicForm>& chars, unsigned startPosition, unsigned endPosition)
{
bool valid = true;
// Check wheter orientation if glyph fits within the request
switch (identifier.orientation) {
case SVGGlyphIdentifier::Vertical:
valid = isVerticalText;
break;
case SVGGlyphIdentifier::Horizontal:
valid = !isVerticalText;
break;
case SVGGlyphIdentifier::Both:
break;
}
if (!valid)
return false;
// Check wheter languages are compatible
if (!identifier.languages.isEmpty()) {
// This glyph exists only in certain languages, if we're not specifying a
// language on the referencing element we're unable to use this glyph.
if (language.isEmpty())
return false;
// Split subcode from language, if existant.
String languagePrefix;
size_t subCodeSeparator = language.find('-');
if (subCodeSeparator != notFound)
languagePrefix = language.left(subCodeSeparator);
Vector<String>::const_iterator it = identifier.languages.begin();
Vector<String>::const_iterator end = identifier.languages.end();
bool found = false;
for (; it != end; ++it) {
const String& cur = *it;
if (cur == language || cur == languagePrefix) {
found = true;
break;
}
}
if (!found)
return false;
}
// Check wheter arabic form is compatible
return isCompatibleArabicForm(identifier, chars, startPosition, endPosition);
}
static inline const SVGFontData* svgFontAndFontFaceElementForFontData(const SimpleFontData* fontData, SVGFontFaceElement*& fontFace, SVGFontElement*& font)
{
ASSERT(fontData->isCustomFont());
ASSERT(fontData->isSVGFont());
const SVGFontData* svgFontData = static_cast<const SVGFontData*>(fontData->svgFontData());
fontFace = svgFontData->svgFontFaceElement();
ASSERT(fontFace);
font = fontFace->associatedFontElement();
return svgFontData;
}
// Helper class to walk a text run. Lookup a SVGGlyphIdentifier for each character
// - also respecting possibly defined ligatures - and invoke a callback for each found glyph.
template<typename SVGTextRunData>
struct SVGTextRunWalker {
typedef bool (*SVGTextRunWalkerCallback)(const SVGGlyphIdentifier&, SVGTextRunData&);
typedef void (*SVGTextRunWalkerMissingGlyphCallback)(const TextRun&, SVGTextRunData&);
SVGTextRunWalker(const SVGFontData* fontData, SVGFontElement* fontElement, SVGTextRunData& data,
SVGTextRunWalkerCallback callback, SVGTextRunWalkerMissingGlyphCallback missingGlyphCallback)
: m_fontData(fontData)
, m_fontElement(fontElement)
, m_walkerData(data)
, m_walkerCallback(callback)
, m_walkerMissingGlyphCallback(missingGlyphCallback)
{
}
void walk(const TextRun& run, bool isVerticalText, const String& language, int from, int to)
{
ASSERT(0 <= from && from <= to && to - from <= run.length());
const String text = Font::normalizeSpaces(run.data(from), to - from);
Vector<SVGGlyphIdentifier::ArabicForm> chars(charactersWithArabicForm(text, run.rtl()));
SVGGlyphIdentifier identifier;
bool foundGlyph = false;
int characterLookupRange;
int endOfScanRange = to + m_walkerData.extraCharsAvailable;
bool haveAltGlyph = false;
SVGGlyphIdentifier altGlyphIdentifier;
if (RenderObject* renderObject = run.referencingRenderObject()) {
RenderObject* parentRenderer = renderObject->parent();
ASSERT(parentRenderer);
if (parentRenderer->node() && parentRenderer->node()->hasTagName(SVGNames::altGlyphTag)) {
SVGGlyphElement* glyphElement = static_cast<SVGAltGlyphElement*>(parentRenderer->node())->glyphElement();
if (glyphElement) {
haveAltGlyph = true;
altGlyphIdentifier = glyphElement->buildGlyphIdentifier();
altGlyphIdentifier.isValid = true;
altGlyphIdentifier.nameLength = to - from;
}
}
}
for (int i = from; i < to; ++i) {
// If characterLookupRange is > 0, then the font defined ligatures (length of unicode property value > 1).
// We have to check wheter the current character & the next character define a ligature. This needs to be
// extended to the n-th next character (where n is 'characterLookupRange'), to check for any possible ligature.
characterLookupRange = endOfScanRange - i;
String lookupString = Font::normalizeSpaces(run.data(i), characterLookupRange);
Vector<SVGGlyphIdentifier> glyphs;
if (haveAltGlyph)
glyphs.append(altGlyphIdentifier);
else
m_fontElement->getGlyphIdentifiersForString(lookupString, glyphs);
Vector<SVGGlyphIdentifier>::iterator it = glyphs.begin();
Vector<SVGGlyphIdentifier>::iterator end = glyphs.end();
for (; it != end; ++it) {
identifier = *it;
if (identifier.isValid && isCompatibleGlyph(identifier, isVerticalText, language, chars, i, i + identifier.nameLength)) {
ASSERT(characterLookupRange > 0);
i += identifier.nameLength - 1;
m_walkerData.charsConsumed += identifier.nameLength;
m_walkerData.glyphName = identifier.glyphName;
foundGlyph = true;
SVGGlyphElement::inheritUnspecifiedAttributes(identifier, m_fontData);
break;
}
}
if (!foundGlyph) {
++m_walkerData.charsConsumed;
if (SVGMissingGlyphElement* element = m_fontElement->firstMissingGlyphElement()) {
// <missing-glyph> element support
identifier = SVGGlyphElement::buildGenericGlyphIdentifier(element);
SVGGlyphElement::inheritUnspecifiedAttributes(identifier, m_fontData);
identifier.isValid = true;
} else {
// Fallback to system font fallback
TextRun subRun(run);
subRun.setText(subRun.data(i), 1);
(*m_walkerMissingGlyphCallback)(subRun, m_walkerData);
continue;
}
}
if (!(*m_walkerCallback)(identifier, m_walkerData))
break;
foundGlyph = false;
}
}
private:
const SVGFontData* m_fontData;
SVGFontElement* m_fontElement;
SVGTextRunData& m_walkerData;
SVGTextRunWalkerCallback m_walkerCallback;
SVGTextRunWalkerMissingGlyphCallback m_walkerMissingGlyphCallback;
};
// Callback & data structures to compute the width of text using SVG Fonts
struct SVGTextRunWalkerMeasuredLengthData {
int at;
int from;
int to;
int extraCharsAvailable;
int charsConsumed;
String glyphName;
float scale;
float length;
const Font* font;
};
static bool floatWidthUsingSVGFontCallback(const SVGGlyphIdentifier& identifier, SVGTextRunWalkerMeasuredLengthData& data)
{
if (data.at >= data.from && data.at < data.to)
data.length += identifier.horizontalAdvanceX * data.scale;
data.at++;
return data.at < data.to;
}
static void floatWidthMissingGlyphCallback(const TextRun& run, SVGTextRunWalkerMeasuredLengthData& data)
{
// Handle system font fallback
FontDescription fontDescription(data.font->fontDescription());
fontDescription.setFamily(FontFamily());
Font font(fontDescription, 0, 0); // spacing handled by SVG text code.
font.update(data.font->fontSelector());
data.length += font.width(run);
}
SVGFontElement* Font::svgFont() const
{
if (!isSVGFont())
return 0;
SVGFontElement* fontElement = 0;
SVGFontFaceElement* fontFaceElement = 0;
if (svgFontAndFontFaceElementForFontData(primaryFont(), fontFaceElement, fontElement))
return fontElement;
return 0;
}
static float floatWidthOfSubStringUsingSVGFont(const Font* font, const TextRun& run, int extraCharsAvailable, int from, int to, int& charsConsumed, String& glyphName)
{
int newFrom = to > from ? from : to;
int newTo = to > from ? to : from;
from = newFrom;
to = newTo;
SVGFontElement* fontElement = 0;
SVGFontFaceElement* fontFaceElement = 0;
if (const SVGFontData* fontData = svgFontAndFontFaceElementForFontData(font->primaryFont(), fontFaceElement, fontElement)) {
if (!fontElement)
return 0.0f;
SVGTextRunWalkerMeasuredLengthData data;
data.font = font;
data.at = from;
data.from = from;
data.to = to;
data.extraCharsAvailable = extraCharsAvailable;
data.charsConsumed = 0;
data.scale = convertEmUnitToPixel(font->size(), fontFaceElement->unitsPerEm(), 1.0f);
data.length = 0.0f;
String language;
bool isVerticalText = false; // Holds true for HTML text
// TODO: language matching & svg glyphs should be possible for HTML text, too.
if (RenderObject* renderObject = run.referencingRenderObject()) {
RenderObject* parentRenderer = renderObject->parent();
ASSERT(parentRenderer);
isVerticalText = isVerticalWritingMode(parentRenderer->style()->svgStyle());
if (SVGElement* element = static_cast<SVGElement*>(parentRenderer->node()))
language = element->getAttribute(XMLNames::langAttr);
}
SVGTextRunWalker<SVGTextRunWalkerMeasuredLengthData> runWalker(fontData, fontElement, data, floatWidthUsingSVGFontCallback, floatWidthMissingGlyphCallback);
runWalker.walk(run, isVerticalText, language, from, to);
charsConsumed = data.charsConsumed;
glyphName = data.glyphName;
return data.length;
}
return 0.0f;
}
float Font::floatWidthUsingSVGFont(const TextRun& run) const
{
int charsConsumed;
String glyphName;
return floatWidthOfSubStringUsingSVGFont(this, run, 0, 0, run.length(), charsConsumed, glyphName);
}
float Font::floatWidthUsingSVGFont(const TextRun& run, int extraCharsAvailable, int& charsConsumed, String& glyphName) const
{
return floatWidthOfSubStringUsingSVGFont(this, run, extraCharsAvailable, 0, run.length(), charsConsumed, glyphName);
}
// Callback & data structures to draw text using SVG Fonts
struct SVGTextRunWalkerDrawTextData {
int extraCharsAvailable;
int charsConsumed;
String glyphName;
Vector<SVGGlyphIdentifier> glyphIdentifiers;
Vector<UChar> fallbackCharacters;
};
static bool drawTextUsingSVGFontCallback(const SVGGlyphIdentifier& identifier, SVGTextRunWalkerDrawTextData& data)
{
data.glyphIdentifiers.append(identifier);
return true;
}
static void drawTextMissingGlyphCallback(const TextRun& run, SVGTextRunWalkerDrawTextData& data)
{
ASSERT(run.length() == 1);
data.glyphIdentifiers.append(SVGGlyphIdentifier());
data.fallbackCharacters.append(run[0]);
}
void Font::drawTextUsingSVGFont(GraphicsContext* context, const TextRun& run,
const FloatPoint& point, int from, int to) const
{
SVGFontElement* fontElement = 0;
SVGFontFaceElement* fontFaceElement = 0;
if (const SVGFontData* fontData = svgFontAndFontFaceElementForFontData(primaryFont(), fontFaceElement, fontElement)) {
if (!fontElement)
return;
SVGTextRunWalkerDrawTextData data;
FloatPoint currentPoint = point;
float scale = convertEmUnitToPixel(size(), fontFaceElement->unitsPerEm(), 1.0f);
RenderSVGResource* activePaintingResource = run.activePaintingResource();
// If renderObject is not set, we're dealing for HTML text rendered using SVG Fonts.
if (!run.referencingRenderObject()) {
ASSERT(!activePaintingResource);
// TODO: We're only supporting simple filled HTML text so far.
RenderSVGResourceSolidColor* solidPaintingResource = RenderSVGResource::sharedSolidPaintingResource();
solidPaintingResource->setColor(context->fillColor());
activePaintingResource = solidPaintingResource;
}
ASSERT(activePaintingResource);
int charsConsumed;
String glyphName;
bool isVerticalText = false;
float xStartOffset = floatWidthOfSubStringUsingSVGFont(this, run, 0, run.rtl() ? to : 0, run.rtl() ? run.length() : from, charsConsumed, glyphName);
FloatPoint glyphOrigin;
String language;
// TODO: language matching & svg glyphs should be possible for HTML text, too.
RenderObject* referencingRenderObject = run.referencingRenderObject();
RenderObject* referencingRenderObjectParent = referencingRenderObject ? referencingRenderObject->parent() : 0;
RenderStyle* referencingRenderObjectParentStyle = 0;
if (referencingRenderObject) {
ASSERT(referencingRenderObjectParent);
referencingRenderObjectParentStyle = referencingRenderObjectParent->style();
isVerticalText = isVerticalWritingMode(referencingRenderObjectParentStyle->svgStyle());
if (SVGElement* element = static_cast<SVGElement*>(referencingRenderObjectParent->node()))
language = element->getAttribute(XMLNames::langAttr);
}
if (!isVerticalText) {
glyphOrigin.setX(fontData->horizontalOriginX() * scale);
glyphOrigin.setY(fontData->horizontalOriginY() * scale);
}
data.extraCharsAvailable = 0;
data.charsConsumed = 0;
SVGTextRunWalker<SVGTextRunWalkerDrawTextData> runWalker(fontData, fontElement, data, drawTextUsingSVGFontCallback, drawTextMissingGlyphCallback);
runWalker.walk(run, isVerticalText, language, from, to);
RenderSVGResourceMode resourceMode = context->textDrawingMode() == TextModeStroke ? ApplyToStrokeMode : ApplyToFillMode;
unsigned numGlyphs = data.glyphIdentifiers.size();
unsigned fallbackCharacterIndex = 0;
for (unsigned i = 0; i < numGlyphs; ++i) {
const SVGGlyphIdentifier& identifier = data.glyphIdentifiers[run.rtl() ? numGlyphs - i - 1 : i];
if (identifier.isValid) {
// FIXME: Support arbitary SVG content as glyph (currently limited to <glyph d="..."> situations).
if (!identifier.pathData.isEmpty()) {
context->save();
if (isVerticalText) {
glyphOrigin.setX(identifier.verticalOriginX * scale);
glyphOrigin.setY(identifier.verticalOriginY * scale);
}
AffineTransform glyphPathTransform;
glyphPathTransform.translate(xStartOffset + currentPoint.x() + glyphOrigin.x(), currentPoint.y() + glyphOrigin.y());
glyphPathTransform.scale(scale, -scale);
Path glyphPath = identifier.pathData;
glyphPath.transform(glyphPathTransform);
if (activePaintingResource->applyResource(referencingRenderObjectParent, referencingRenderObjectParentStyle, context, resourceMode)) {
if (referencingRenderObject) {
RenderSVGInlineText* textRenderer = toRenderSVGInlineText(referencingRenderObject);
context->setStrokeThickness(context->strokeThickness() * textRenderer->scalingFactor());
}
activePaintingResource->postApplyResource(referencingRenderObjectParent, context, resourceMode, &glyphPath);
}
context->restore();
}
if (isVerticalText)
currentPoint.move(0.0f, identifier.verticalAdvanceY * scale);
else
currentPoint.move(identifier.horizontalAdvanceX * scale, 0.0f);
} else {
// Handle system font fallback
FontDescription fontDescription(m_fontDescription);
fontDescription.setFamily(FontFamily());
Font font(fontDescription, 0, 0); // spacing handled by SVG text code.
font.update(fontSelector());
TextRun fallbackCharacterRun(run);
fallbackCharacterRun.setText(&data.fallbackCharacters[run.rtl() ? data.fallbackCharacters.size() - fallbackCharacterIndex - 1 : fallbackCharacterIndex], 1);
font.drawText(context, fallbackCharacterRun, currentPoint);
if (isVerticalText)
currentPoint.move(0.0f, font.width(fallbackCharacterRun));
else
currentPoint.move(font.width(fallbackCharacterRun), 0.0f);
fallbackCharacterIndex++;
}
}
}
}
FloatRect Font::selectionRectForTextUsingSVGFont(const TextRun& run, const FloatPoint& point, int height, int from, int to) const
{
int charsConsumed;
String glyphName;
return FloatRect(point.x() + floatWidthOfSubStringUsingSVGFont(this, run, 0, run.rtl() ? to : 0, run.rtl() ? run.length() : from, charsConsumed, glyphName),
point.y(), floatWidthOfSubStringUsingSVGFont(this, run, 0, from, to, charsConsumed, glyphName), height);
}
int Font::offsetForPositionForTextUsingSVGFont(const TextRun&, float, bool) const
{
// TODO: Fix text selection when HTML text is drawn using a SVG Font
// We need to integrate the SVG text selection code in the offsetForPosition() framework.
// This will also fix a major issue, that SVG Text code can't select arabic strings properly.
return 0;
}
}
#endif