WebCore/svg/SVGFontFaceElement.cpp - third_party/webkit - Git at Google

 /*
    Copyright (C) 2007 Eric Seidel <eric@webkit.org>
    Copyright (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>

    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 "CString.h"
 #include "CSSFontFaceRule.h"
 #include "CSSFontFaceSrcValue.h"
 #include "CSSProperty.h"
 #include "CSSPropertyNames.h"
 #include "CSSStyleSelector.h"
 #include "CSSStyleSheet.h"
 #include "CSSValueKeywords.h"
 #include "CSSValueList.h"
 #include "FontCache.h"
 #include "FontPlatformData.h"
 #include "SimpleFontData.h"
 #include "SVGDefinitionSrcElement.h"
 #include "SVGFontElement.h"
 #include "SVGFontFaceSrcElement.h"
 #include "SVGGlyphElement.h"
 #include "SVGNames.h"

 #include <math.h>

 namespace WebCore {

 using namespace SVGNames;

 SVGFontFaceElement::SVGFontFaceElement(const QualifiedName& tagName, Document* doc)
     : SVGElement(tagName, doc)
     , m_fontFaceRule(new CSSFontFaceRule(0))
     , m_styleDeclaration(new CSSMutableStyleDeclaration)
 {
     m_styleDeclaration->setParent(document()->mappedElementSheet());
     m_styleDeclaration->setStrictParsing(true);
     m_fontFaceRule->setDeclaration(m_styleDeclaration.get());
     document()->mappedElementSheet()->append(m_fontFaceRule);
 }

 SVGFontFaceElement::~SVGFontFaceElement()
 {
 }

 static inline void mapAttributeToCSSProperty(HashMap<AtomicStringImpl*, int>* propertyNameToIdMap, const QualifiedName& attrName, const char* cssPropertyName = 0)
 {
     int propertyId = 0;
     if (cssPropertyName)
         propertyId = getPropertyID(cssPropertyName, strlen(cssPropertyName));
     else {
         CString propertyName = attrName.localName().domString().utf8();
         propertyId = getPropertyID(propertyName.data(), propertyName.length());
     }
     if (propertyId < 1)
         fprintf(stderr, "Failed to find property: %s\n", attrName.localName().deprecatedString().ascii());
     ASSERT(propertyId > 0);
     propertyNameToIdMap->set(attrName.localName().impl(), propertyId);
 }

 static int cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
 {
     if (!attrName.namespaceURI().isNull())
         return 0;

     static HashMap<AtomicStringImpl*, int>* propertyNameToIdMap = 0;
     if (!propertyNameToIdMap) {
         propertyNameToIdMap = new HashMap<AtomicStringImpl*, int>;
         // 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(MappedAttribute* attr)
 {
     int propId = cssPropertyIdForSVGAttributeName(attr->name());
     if (propId > 0) {
         m_styleDeclaration->setProperty(propId, attr->value(), false);
         rebuildFontFace();
         return;
     }

     SVGElement::parseMappedAttribute(attr);
 }

 unsigned SVGFontFaceElement::unitsPerEm() const
 {
     AtomicString value(getAttribute(units_per_emAttr));
     if (value.isEmpty())
         return 1000;

     return static_cast<unsigned>(ceilf(value.toFloat()));
 }

 int SVGFontFaceElement::xHeight() const
 {
     AtomicString value(getAttribute(x_heightAttr));
     if (value.isEmpty())
         return 0;

     return static_cast<int>(ceilf(value.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.
     AtomicString value(m_fontElement->getAttribute(horiz_origin_xAttr));
     if (value.isEmpty())
         return 0.0f;

     return value.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.
     AtomicString value(m_fontElement->getAttribute(horiz_origin_yAttr));
     if (value.isEmpty())
         return 0.0f;

     return value.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.
     AtomicString value(m_fontElement->getAttribute(horiz_adv_xAttr));
     if (value.isEmpty())
         return 0.0f;

     return value.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.
     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.
     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).
     AtomicString value(m_fontElement->getAttribute(vert_adv_yAttr));
        if (value.isEmpty())
         return 1.0f;

     return value.toFloat();
 }

 int SVGFontFaceElement::ascent() const
 {
     if (!m_fontElement)
         return 0.0f;

     // 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.
     AtomicString value(m_fontElement->getAttribute(ascentAttr));
     if (!value.isEmpty())
         return static_cast<int>(ceilf(value.toFloat()));

     value = m_fontElement->getAttribute(vert_origin_yAttr);
     if (!value.isEmpty())
         return static_cast<int>(unitsPerEm()) - static_cast<int>(ceilf(value.toFloat()));

     // Match Batiks default value
     return static_cast<int>(ceilf(unitsPerEm() * 0.8f));
 }

 int SVGFontFaceElement::descent() const
 {
     if (!m_fontElement)
         return 0.0f;

     // 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.
     AtomicString value(m_fontElement->getAttribute(descentAttr));
     if (!value.isEmpty()) {
         // Some testcases use a negative descent value, where a positive was meant to be used :(
         int descent = static_cast<int>(ceilf(value.toFloat()));
         return descent < 0 ? -descent : descent;
     }

     value = m_fontElement->getAttribute(vert_origin_yAttr);
     if (!value.isEmpty())
         return static_cast<int>(ceilf(value.toFloat()));

     // Match Batiks default value
     return static_cast<int>(ceilf(unitsPerEm() * 0.2f));
 }

 String SVGFontFaceElement::fontFamily() const
 {
     return m_styleDeclaration->getPropertyValue(CSS_PROP_FONT_FAMILY);
 }

 SVGFontElement* SVGFontFaceElement::associatedFontElement() const
 {
     return m_fontElement.get();
 }

 void SVGFontFaceElement::rebuildFontFace()
 {
     // Ignore changes until we live in the tree
     if (!parentNode())
         return;

     // we currently ignore all but the first src element, alternatively we could concat them
     SVGFontFaceSrcElement* srcElement = 0;
     SVGDefinitionSrcElement* definitionSrc = 0;

     for (Node* child = firstChild(); child; child = child->nextSibling()) {
         if (child->hasTagName(font_face_srcTag) && !srcElement)
             srcElement = static_cast<SVGFontFaceSrcElement*>(child);
         else if (child->hasTagName(definition_srcTag) && !definitionSrc)
             definitionSrc = static_cast<SVGDefinitionSrcElement*>(child);
     }

 #if 0
     // @font-face (CSSFontFace) does not yet support definition-src, as soon as it does this code should do the trick!
     if (definitionSrc)
         m_styleDeclaration->setProperty(CSS_PROP_DEFINITION_SRC, definitionSrc->getAttribute(XLinkNames::hrefAttr), false);
 #endif

     bool describesParentFont = parentNode()->hasTagName(fontTag);
     RefPtr<CSSValueList> list;

     if (describesParentFont) {
         m_fontElement = static_cast<SVGFontElement*>(parentNode());

         list = new CSSValueList;
         list->append(new CSSFontFaceSrcValue(fontFamily(), true));
     } else if (srcElement)
         list = srcElement->srcValue();

     if (!list)
         return;

     // Parse in-memory CSS rules
     CSSProperty srcProperty(CSS_PROP_SRC, list);
     const CSSProperty* srcPropertyRef = &srcProperty;
     m_styleDeclaration->addParsedProperties(&srcPropertyRef, 1);

     if (describesParentFont) {
         // Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves.
         RefPtr<CSSValue> src = m_styleDeclaration->getPropertyCSSValue(CSS_PROP_SRC);
         CSSValueList* srcList = static_cast<CSSValueList*>(src.get());

         unsigned srcLength = srcList ? srcList->length() : 0;
         for (unsigned i = 0; i < srcLength; i++) {
             if (CSSFontFaceSrcValue* item = static_cast<CSSFontFaceSrcValue*>(srcList->item(i)))
                 item->setSVGFontFaceElement(this);
         }
     }

     document()->updateStyleSelector();
 }

 void SVGFontFaceElement::insertedIntoDocument()
 {
     rebuildFontFace();
 }

 void SVGFontFaceElement::childrenChanged(bool changedByParser)
 {
     SVGElement::childrenChanged(changedByParser);
     rebuildFontFace();
 }

 }

 #endif // ENABLE(SVG_FONTS)
	/*
	Copyright (C) 2007 Eric Seidel <eric@webkit.org>
	Copyright (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>

	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 "CString.h"
	#include "CSSFontFaceRule.h"
	#include "CSSFontFaceSrcValue.h"
	#include "CSSProperty.h"
	#include "CSSPropertyNames.h"
	#include "CSSStyleSelector.h"
	#include "CSSStyleSheet.h"
	#include "CSSValueKeywords.h"
	#include "CSSValueList.h"
	#include "FontCache.h"
	#include "FontPlatformData.h"
	#include "SimpleFontData.h"
	#include "SVGDefinitionSrcElement.h"
	#include "SVGFontElement.h"
	#include "SVGFontFaceSrcElement.h"
	#include "SVGGlyphElement.h"
	#include "SVGNames.h"

	#include <math.h>

	namespace WebCore {

	using namespace SVGNames;

	SVGFontFaceElement::SVGFontFaceElement(const QualifiedName& tagName, Document* doc)
	: SVGElement(tagName, doc)
	, m_fontFaceRule(new CSSFontFaceRule(0))
	, m_styleDeclaration(new CSSMutableStyleDeclaration)
	{
	m_styleDeclaration->setParent(document()->mappedElementSheet());
	m_styleDeclaration->setStrictParsing(true);
	m_fontFaceRule->setDeclaration(m_styleDeclaration.get());
	document()->mappedElementSheet()->append(m_fontFaceRule);
	}

	SVGFontFaceElement::~SVGFontFaceElement()
	{
	}

	static inline void mapAttributeToCSSProperty(HashMap<AtomicStringImpl, int> propertyNameToIdMap, const QualifiedName& attrName, const char* cssPropertyName = 0)
	{
	int propertyId = 0;
	if (cssPropertyName)
	propertyId = getPropertyID(cssPropertyName, strlen(cssPropertyName));
	else {
	CString propertyName = attrName.localName().domString().utf8();
	propertyId = getPropertyID(propertyName.data(), propertyName.length());
	}
	if (propertyId < 1)
	fprintf(stderr, "Failed to find property: %s\n", attrName.localName().deprecatedString().ascii());
	ASSERT(propertyId > 0);
	propertyNameToIdMap->set(attrName.localName().impl(), propertyId);
	}

	static int cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
	{
	if (!attrName.namespaceURI().isNull())
	return 0;

	static HashMap<AtomicStringImpl, int> propertyNameToIdMap = 0;
	if (!propertyNameToIdMap) {
	propertyNameToIdMap = new HashMap<AtomicStringImpl*, int>;
	// 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(MappedAttribute* attr)
	{
	int propId = cssPropertyIdForSVGAttributeName(attr->name());
	if (propId > 0) {
	m_styleDeclaration->setProperty(propId, attr->value(), false);
	rebuildFontFace();
	return;
	}

	SVGElement::parseMappedAttribute(attr);
	}

	unsigned SVGFontFaceElement::unitsPerEm() const
	{
	AtomicString value(getAttribute(units_per_emAttr));
	if (value.isEmpty())
	return 1000;

	return static_cast<unsigned>(ceilf(value.toFloat()));
	}

	int SVGFontFaceElement::xHeight() const
	{
	AtomicString value(getAttribute(x_heightAttr));
	if (value.isEmpty())
	return 0;

	return static_cast<int>(ceilf(value.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.
	AtomicString value(m_fontElement->getAttribute(horiz_origin_xAttr));
	if (value.isEmpty())
	return 0.0f;

	return value.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.
	AtomicString value(m_fontElement->getAttribute(horiz_origin_yAttr));
	if (value.isEmpty())
	return 0.0f;

	return value.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.
	AtomicString value(m_fontElement->getAttribute(horiz_adv_xAttr));
	if (value.isEmpty())
	return 0.0f;

	return value.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.
	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.
	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).
	AtomicString value(m_fontElement->getAttribute(vert_adv_yAttr));
	if (value.isEmpty())
	return 1.0f;

	return value.toFloat();
	}

	int SVGFontFaceElement::ascent() const
	{
	if (!m_fontElement)
	return 0.0f;

	// 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.
	AtomicString value(m_fontElement->getAttribute(ascentAttr));
	if (!value.isEmpty())
	return static_cast<int>(ceilf(value.toFloat()));

	value = m_fontElement->getAttribute(vert_origin_yAttr);
	if (!value.isEmpty())
	return static_cast<int>(unitsPerEm()) - static_cast<int>(ceilf(value.toFloat()));

	// Match Batiks default value
	return static_cast<int>(ceilf(unitsPerEm() * 0.8f));
	}

	int SVGFontFaceElement::descent() const
	{
	if (!m_fontElement)
	return 0.0f;

	// 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.
	AtomicString value(m_fontElement->getAttribute(descentAttr));
	if (!value.isEmpty()) {
	// Some testcases use a negative descent value, where a positive was meant to be used :(
	int descent = static_cast<int>(ceilf(value.toFloat()));
	return descent < 0 ? -descent : descent;
	}

	value = m_fontElement->getAttribute(vert_origin_yAttr);
	if (!value.isEmpty())
	return static_cast<int>(ceilf(value.toFloat()));

	// Match Batiks default value
	return static_cast<int>(ceilf(unitsPerEm() * 0.2f));
	}

	String SVGFontFaceElement::fontFamily() const
	{
	return m_styleDeclaration->getPropertyValue(CSS_PROP_FONT_FAMILY);
	}

	SVGFontElement* SVGFontFaceElement::associatedFontElement() const
	{
	return m_fontElement.get();
	}

	void SVGFontFaceElement::rebuildFontFace()
	{
	// Ignore changes until we live in the tree
	if (!parentNode())
	return;

	// we currently ignore all but the first src element, alternatively we could concat them
	SVGFontFaceSrcElement* srcElement = 0;
	SVGDefinitionSrcElement* definitionSrc = 0;

	for (Node* child = firstChild(); child; child = child->nextSibling()) {
	if (child->hasTagName(font_face_srcTag) && !srcElement)
	srcElement = static_cast<SVGFontFaceSrcElement*>(child);
	else if (child->hasTagName(definition_srcTag) && !definitionSrc)
	definitionSrc = static_cast<SVGDefinitionSrcElement*>(child);
	}

	#if 0
	// @font-face (CSSFontFace) does not yet support definition-src, as soon as it does this code should do the trick!
	if (definitionSrc)
	m_styleDeclaration->setProperty(CSS_PROP_DEFINITION_SRC, definitionSrc->getAttribute(XLinkNames::hrefAttr), false);
	#endif

	bool describesParentFont = parentNode()->hasTagName(fontTag);
	RefPtr<CSSValueList> list;

	if (describesParentFont) {
	m_fontElement = static_cast<SVGFontElement*>(parentNode());

	list = new CSSValueList;
	list->append(new CSSFontFaceSrcValue(fontFamily(), true));
	} else if (srcElement)
	list = srcElement->srcValue();

	if (!list)
	return;

	// Parse in-memory CSS rules
	CSSProperty srcProperty(CSS_PROP_SRC, list);
	const CSSProperty* srcPropertyRef = &srcProperty;
	m_styleDeclaration->addParsedProperties(&srcPropertyRef, 1);

	if (describesParentFont) {
	// Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves.
	RefPtr<CSSValue> src = m_styleDeclaration->getPropertyCSSValue(CSS_PROP_SRC);
	CSSValueList* srcList = static_cast<CSSValueList*>(src.get());

	unsigned srcLength = srcList ? srcList->length() : 0;
	for (unsigned i = 0; i < srcLength; i++) {
	if (CSSFontFaceSrcValue* item = static_cast<CSSFontFaceSrcValue*>(srcList->item(i)))
	item->setSVGFontFaceElement(this);
	}
	}

	document()->updateStyleSelector();
	}

	void SVGFontFaceElement::insertedIntoDocument()
	{
	rebuildFontFace();
	}

	void SVGFontFaceElement::childrenChanged(bool changedByParser)
	{
	SVGElement::childrenChanged(changedByParser);
	rebuildFontFace();
	}

	}

	#endif // ENABLE(SVG_FONTS)