Long live Qt 4.5!

1 files changed, 368 insertions, 0 deletions

diff --git a/src/3rdparty/webkit/WebCore/svg/SVGFontFaceElement.cpp b/src/3rdparty/webkit/WebCore/svg/SVGFontFaceElement.cpp
new file mode 100644
index 0000000..973e890
--- /dev/null
+++ b/src/3rdparty/webkit/WebCore/svg/SVGFontFaceElement.cpp
@@ -0,0 +1,368 @@
+/*
+   Copyright (C) 2007 Eric Seidel <eric@webkit.org>
+   Copyright (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
+   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 "CString.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 "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(CSSFontFaceRule::create())
+    , m_styleDeclaration(CSSMutableStyleDeclaration::create())
+{
+    m_styleDeclaration->setParent(document()->mappedElementSheet());
+    m_styleDeclaration->setStrictParsing(true);
+    m_fontFaceRule->setDeclaration(m_styleDeclaration.get());
+}
+
+SVGFontFaceElement::~SVGFontFaceElement()
+{
+    removeFromMappedElementSheet();
+}
+
+static void mapAttributeToCSSProperty(HashMap<AtomicStringImpl*, int>* propertyNameToIdMap, const QualifiedName& attrName)
+{
+    int propertyId = cssPropertyID(attrName.localName());
+    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);
+        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<unsigned>(ceilf(value.toFloat()));
+}
+
+int SVGFontFaceElement::xHeight() const
+{
+    return static_cast<int>(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<int>(ceilf(ascentValue.toFloat()));
+
+    if (m_fontElement) {
+        const AtomicString& vertOriginY = m_fontElement->getAttribute(vert_origin_yAttr);
+        if (!vertOriginY.isEmpty())
+            return static_cast<int>(unitsPerEm()) - static_cast<int>(ceilf(vertOriginY.toFloat()));
+    }
+
+    // Match Batiks default value
+    return static_cast<int>(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<int>(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<int>(ceilf(vertOriginY.toFloat()));
+    }
+
+    // Match Batiks default value
+    return static_cast<int>(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;
+    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(CSSPropertyDefinitionSrc, definitionSrc->getAttribute(XLinkNames::hrefAttr), false);
+#endif
+
+    bool describesParentFont = parentNode()->hasTagName(fontTag);
+    RefPtr<CSSValueList> list;
+
+    if (describesParentFont) {
+        m_fontElement = static_cast<SVGFontElement*>(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<CSSValue> src = m_styleDeclaration->getPropertyCSSValue(CSSPropertySrc);
+        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->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)