diff -r 000000000000 -r 4f2f89ce4247 WebCore/svg/SVGFontFaceElement.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/WebCore/svg/SVGFontFaceElement.cpp Fri Sep 17 09:02:29 2010 +0300 @@ -0,0 +1,350 @@ +/* + Copyright (C) 2007 Eric Seidel + Copyright (C) 2007, 2008 Nikolas Zimmermann + Copyright (C) 2008 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 "config.h" + +#if ENABLE(SVG_FONTS) +#include "SVGFontFaceElement.h" + +#include "Attribute.h" +#include "CSSFontFaceRule.h" +#include "CSSFontFaceSrcValue.h" +#include "CSSParser.h" +#include "CSSProperty.h" +#include "CSSPropertyNames.h" +#include "CSSStyleSelector.h" +#include "CSSStyleSheet.h" +#include "CSSValueKeywords.h" +#include "CSSValueList.h" +#include "Document.h" +#include "Font.h" +#include "SVGFontElement.h" +#include "SVGFontFaceSrcElement.h" +#include "SVGGlyphElement.h" +#include "SVGNames.h" +#include + +namespace WebCore { + +using namespace SVGNames; + +SVGFontFaceElement::SVGFontFaceElement(const QualifiedName& tagName, Document* doc) + : SVGElement(tagName, doc) + , m_fontFaceRule(CSSFontFaceRule::create()) + , m_styleDeclaration(CSSMutableStyleDeclaration::create()) +{ + m_styleDeclaration->setParent(document()->mappedElementSheet()); + m_styleDeclaration->setStrictParsing(true); + m_fontFaceRule->setDeclaration(m_styleDeclaration.get()); +} + +SVGFontFaceElement::~SVGFontFaceElement() +{ +} + +static int cssPropertyIdForSVGAttributeName(const QualifiedName& attrName) +{ + if (!attrName.namespaceURI().isNull()) + return 0; + + static HashMap* propertyNameToIdMap = 0; + if (!propertyNameToIdMap) { + propertyNameToIdMap = new HashMap; + // This is a list of all @font-face CSS properties which are exposed as SVG XML attributes + // Those commented out are not yet supported by WebCore's style system + //mapAttributeToCSSProperty(propertyNameToIdMap, accent_heightAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, alphabeticAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, ascentAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, bboxAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, cap_heightAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, descentAttr); + mapAttributeToCSSProperty(propertyNameToIdMap, font_familyAttr); + mapAttributeToCSSProperty(propertyNameToIdMap, font_sizeAttr); + mapAttributeToCSSProperty(propertyNameToIdMap, font_stretchAttr); + mapAttributeToCSSProperty(propertyNameToIdMap, font_styleAttr); + mapAttributeToCSSProperty(propertyNameToIdMap, font_variantAttr); + mapAttributeToCSSProperty(propertyNameToIdMap, font_weightAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, hangingAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, ideographicAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, mathematicalAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, overline_positionAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, overline_thicknessAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, panose_1Attr); + //mapAttributeToCSSProperty(propertyNameToIdMap, slopeAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, stemhAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, stemvAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_positionAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_thicknessAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, underline_positionAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, underline_thicknessAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, unicode_rangeAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, units_per_emAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, v_alphabeticAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, v_hangingAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, v_ideographicAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, v_mathematicalAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, widthsAttr); + //mapAttributeToCSSProperty(propertyNameToIdMap, x_heightAttr); + } + + return propertyNameToIdMap->get(attrName.localName().impl()); +} + +void SVGFontFaceElement::parseMappedAttribute(Attribute* attr) +{ + int propId = cssPropertyIdForSVGAttributeName(attr->name()); + if (propId > 0) { + m_styleDeclaration->setProperty(propId, attr->value(), false); + if (inDocument()) + rebuildFontFace(); + return; + } + + SVGElement::parseMappedAttribute(attr); +} + +unsigned SVGFontFaceElement::unitsPerEm() const +{ + const AtomicString& value = getAttribute(units_per_emAttr); + if (value.isEmpty()) + return defaultUnitsPerEm; + + return static_cast(ceilf(value.toFloat())); +} + +int SVGFontFaceElement::xHeight() const +{ + return static_cast(ceilf(getAttribute(x_heightAttr).toFloat())); +} + +float SVGFontFaceElement::horizontalOriginX() const +{ + if (!m_fontElement) + return 0.0f; + + // Spec: The X-coordinate in the font coordinate system of the origin of a glyph to be used when + // drawing horizontally oriented text. (Note that the origin applies to all glyphs in the font.) + // If the attribute is not specified, the effect is as if a value of "0" were specified. + return m_fontElement->getAttribute(horiz_origin_xAttr).toFloat(); +} + +float SVGFontFaceElement::horizontalOriginY() const +{ + if (!m_fontElement) + return 0.0f; + + // Spec: The Y-coordinate in the font coordinate system of the origin of a glyph to be used when + // drawing horizontally oriented text. (Note that the origin applies to all glyphs in the font.) + // If the attribute is not specified, the effect is as if a value of "0" were specified. + return m_fontElement->getAttribute(horiz_origin_yAttr).toFloat(); +} + +float SVGFontFaceElement::horizontalAdvanceX() const +{ + if (!m_fontElement) + return 0.0f; + + // Spec: The default horizontal advance after rendering a glyph in horizontal orientation. Glyph + // widths are required to be non-negative, even if the glyph is typically rendered right-to-left, + // as in Hebrew and Arabic scripts. + return m_fontElement->getAttribute(horiz_adv_xAttr).toFloat(); +} + +float SVGFontFaceElement::verticalOriginX() const +{ + if (!m_fontElement) + return 0.0f; + + // Spec: The default X-coordinate in the font coordinate system of the origin of a glyph to be used when + // drawing vertically oriented text. If the attribute is not specified, the effect is as if the attribute + // were set to half of the effective value of attribute horiz-adv-x. + const AtomicString& value = m_fontElement->getAttribute(vert_origin_xAttr); + if (value.isEmpty()) + return horizontalAdvanceX() / 2.0f; + + return value.toFloat(); +} + +float SVGFontFaceElement::verticalOriginY() const +{ + if (!m_fontElement) + return 0.0f; + + // Spec: The default Y-coordinate in the font coordinate system of the origin of a glyph to be used when + // drawing vertically oriented text. If the attribute is not specified, the effect is as if the attribute + // were set to the position specified by the font's ascent attribute. + const AtomicString& value = m_fontElement->getAttribute(vert_origin_yAttr); + if (value.isEmpty()) + return ascent(); + + return value.toFloat(); +} + +float SVGFontFaceElement::verticalAdvanceY() const +{ + if (!m_fontElement) + return 0.0f; + + // Spec: The default vertical advance after rendering a glyph in vertical orientation. If the attribute is + // not specified, the effect is as if a value equivalent of one em were specified (see units-per-em). + const AtomicString& value = m_fontElement->getAttribute(vert_adv_yAttr); + if (value.isEmpty()) + return 1.0f; + + return value.toFloat(); +} + +int SVGFontFaceElement::ascent() const +{ + // Spec: Same syntax and semantics as the 'ascent' descriptor within an @font-face rule. The maximum + // unaccented height of the font within the font coordinate system. If the attribute is not specified, + // the effect is as if the attribute were set to the difference between the units-per-em value and the + // vert-origin-y value for the corresponding font. + const AtomicString& ascentValue = getAttribute(ascentAttr); + if (!ascentValue.isEmpty()) + return static_cast(ceilf(ascentValue.toFloat())); + + if (m_fontElement) { + const AtomicString& vertOriginY = m_fontElement->getAttribute(vert_origin_yAttr); + if (!vertOriginY.isEmpty()) + return static_cast(unitsPerEm()) - static_cast(ceilf(vertOriginY.toFloat())); + } + + // Match Batiks default value + return static_cast(ceilf(unitsPerEm() * 0.8f)); +} + +int SVGFontFaceElement::descent() const +{ + // Spec: Same syntax and semantics as the 'descent' descriptor within an @font-face rule. The maximum + // unaccented depth of the font within the font coordinate system. If the attribute is not specified, + // the effect is as if the attribute were set to the vert-origin-y value for the corresponding font. + const AtomicString& descentValue = getAttribute(descentAttr); + if (!descentValue.isEmpty()) { + // 14 different W3C SVG 1.1 testcases use a negative descent value, + // where a positive was meant to be used Including: + // animate-elem-24-t.svg, fonts-elem-01-t.svg, fonts-elem-02-t.svg (and 11 others) + int descent = static_cast(ceilf(descentValue.toFloat())); + return descent < 0 ? -descent : descent; + } + + if (m_fontElement) { + const AtomicString& vertOriginY = m_fontElement->getAttribute(vert_origin_yAttr); + if (!vertOriginY.isEmpty()) + return static_cast(ceilf(vertOriginY.toFloat())); + } + + // Match Batiks default value + return static_cast(ceilf(unitsPerEm() * 0.2f)); +} + +String SVGFontFaceElement::fontFamily() const +{ + return m_styleDeclaration->getPropertyValue(CSSPropertyFontFamily); +} + +void SVGFontFaceElement::rebuildFontFace() +{ + ASSERT(inDocument()); + + // we currently ignore all but the first src element, alternatively we could concat them + SVGFontFaceSrcElement* srcElement = 0; + + for (Node* child = firstChild(); child && !srcElement; child = child->nextSibling()) { + if (child->hasTagName(font_face_srcTag)) + srcElement = static_cast(child); + } + + bool describesParentFont = parentNode()->hasTagName(SVGNames::fontTag); + RefPtr list; + + if (describesParentFont) { + m_fontElement = static_cast(parentNode()); + + list = CSSValueList::createCommaSeparated(); + list->append(CSSFontFaceSrcValue::createLocal(fontFamily())); + } else { + m_fontElement = 0; + if (srcElement) + list = srcElement->srcValue(); + } + + if (!list) + return; + + // Parse in-memory CSS rules + CSSProperty srcProperty(CSSPropertySrc, list); + const CSSProperty* srcPropertyRef = &srcProperty; + m_styleDeclaration->addParsedProperties(&srcPropertyRef, 1); + + if (describesParentFont) { + // Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves. + RefPtr src = m_styleDeclaration->getPropertyCSSValue(CSSPropertySrc); + CSSValueList* srcList = static_cast(src.get()); + + unsigned srcLength = srcList ? srcList->length() : 0; + for (unsigned i = 0; i < srcLength; i++) { + if (CSSFontFaceSrcValue* item = static_cast(srcList->itemWithoutBoundsCheck(i))) + item->setSVGFontFaceElement(this); + } + } + + document()->updateStyleSelector(); +} + +void SVGFontFaceElement::insertedIntoDocument() +{ + SVGElement::insertedIntoDocument(); + document()->mappedElementSheet()->append(m_fontFaceRule); + rebuildFontFace(); +} + +void SVGFontFaceElement::removedFromDocument() +{ + removeFromMappedElementSheet(); + SVGElement::removedFromDocument(); +} + +void SVGFontFaceElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta) +{ + SVGElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta); + if (inDocument()) + rebuildFontFace(); +} + +void SVGFontFaceElement::removeFromMappedElementSheet() +{ + CSSStyleSheet* mappedElementSheet = document()->mappedElementSheet(); + if (!mappedElementSheet) + return; + + for (unsigned i = 0; i < mappedElementSheet->length(); ++i) { + if (mappedElementSheet->item(i) == m_fontFaceRule) { + mappedElementSheet->remove(i); + break; + } + } + document()->updateStyleSelector(); +} + +} // namespace WebCore + +#endif // ENABLE(SVG_FONTS)