Split remaining CSSRules into internal and CSSOM types
[WebKit-https.git] / Source / WebCore / svg / SVGFontFaceElement.cpp
1 /*
2  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
3  * Copyright (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
4  * Copyright (C) 2008 Apple Inc. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23
24 #if ENABLE(SVG_FONTS)
25 #include "SVGFontFaceElement.h"
26
27 #include "Attribute.h"
28 #include "CSSFontFaceSrcValue.h"
29 #include "CSSParser.h"
30 #include "CSSProperty.h"
31 #include "CSSPropertyNames.h"
32 #include "CSSStyleSelector.h"
33 #include "CSSStyleSheet.h"
34 #include "CSSValueKeywords.h"
35 #include "CSSValueList.h"
36 #include "Document.h"
37 #include "Font.h"
38 #include "SVGDocumentExtensions.h"
39 #include "SVGFontElement.h"
40 #include "SVGFontFaceSrcElement.h"
41 #include "SVGGlyphElement.h"
42 #include "SVGNames.h"
43 #include "StyleRule.h"
44 #include <math.h>
45
46 namespace WebCore {
47
48 using namespace SVGNames;
49
50 inline SVGFontFaceElement::SVGFontFaceElement(const QualifiedName& tagName, Document* document)
51     : SVGElement(tagName, document)
52     , m_fontFaceRule(StyleRuleFontFace::create())
53 {
54     ASSERT(hasTagName(font_faceTag));
55     RefPtr<StylePropertySet> styleDeclaration = StylePropertySet::create(CSSStrictMode);
56     m_fontFaceRule->setProperties(styleDeclaration.release());
57 }
58
59 PassRefPtr<SVGFontFaceElement> SVGFontFaceElement::create(const QualifiedName& tagName, Document* document)
60 {
61     return adoptRef(new SVGFontFaceElement(tagName, document));
62 }
63
64 static int cssPropertyIdForSVGAttributeName(const QualifiedName& attrName)
65 {
66     if (!attrName.namespaceURI().isNull())
67         return 0;
68     
69     static HashMap<AtomicStringImpl*, int>* propertyNameToIdMap = 0;
70     if (!propertyNameToIdMap) {
71         propertyNameToIdMap = new HashMap<AtomicStringImpl*, int>;
72         // This is a list of all @font-face CSS properties which are exposed as SVG XML attributes
73         // Those commented out are not yet supported by WebCore's style system
74         // mapAttributeToCSSProperty(propertyNameToIdMap, accent_heightAttr);
75         // mapAttributeToCSSProperty(propertyNameToIdMap, alphabeticAttr);
76         // mapAttributeToCSSProperty(propertyNameToIdMap, ascentAttr);
77         // mapAttributeToCSSProperty(propertyNameToIdMap, bboxAttr);
78         // mapAttributeToCSSProperty(propertyNameToIdMap, cap_heightAttr);
79         // mapAttributeToCSSProperty(propertyNameToIdMap, descentAttr);
80         mapAttributeToCSSProperty(propertyNameToIdMap, font_familyAttr);
81         mapAttributeToCSSProperty(propertyNameToIdMap, font_sizeAttr);
82         mapAttributeToCSSProperty(propertyNameToIdMap, font_stretchAttr);
83         mapAttributeToCSSProperty(propertyNameToIdMap, font_styleAttr);
84         mapAttributeToCSSProperty(propertyNameToIdMap, font_variantAttr);
85         mapAttributeToCSSProperty(propertyNameToIdMap, font_weightAttr);
86         // mapAttributeToCSSProperty(propertyNameToIdMap, hangingAttr);
87         // mapAttributeToCSSProperty(propertyNameToIdMap, ideographicAttr);
88         // mapAttributeToCSSProperty(propertyNameToIdMap, mathematicalAttr);
89         // mapAttributeToCSSProperty(propertyNameToIdMap, overline_positionAttr);
90         // mapAttributeToCSSProperty(propertyNameToIdMap, overline_thicknessAttr);
91         // mapAttributeToCSSProperty(propertyNameToIdMap, panose_1Attr);
92         // mapAttributeToCSSProperty(propertyNameToIdMap, slopeAttr);
93         // mapAttributeToCSSProperty(propertyNameToIdMap, stemhAttr);
94         // mapAttributeToCSSProperty(propertyNameToIdMap, stemvAttr);
95         // mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_positionAttr);
96         // mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_thicknessAttr);
97         // mapAttributeToCSSProperty(propertyNameToIdMap, underline_positionAttr);
98         // mapAttributeToCSSProperty(propertyNameToIdMap, underline_thicknessAttr);
99         // mapAttributeToCSSProperty(propertyNameToIdMap, unicode_rangeAttr);
100         // mapAttributeToCSSProperty(propertyNameToIdMap, units_per_emAttr);
101         // mapAttributeToCSSProperty(propertyNameToIdMap, v_alphabeticAttr);
102         // mapAttributeToCSSProperty(propertyNameToIdMap, v_hangingAttr);
103         // mapAttributeToCSSProperty(propertyNameToIdMap, v_ideographicAttr);
104         // mapAttributeToCSSProperty(propertyNameToIdMap, v_mathematicalAttr);
105         // mapAttributeToCSSProperty(propertyNameToIdMap, widthsAttr);
106         // mapAttributeToCSSProperty(propertyNameToIdMap, x_heightAttr);
107     }
108     
109     return propertyNameToIdMap->get(attrName.localName().impl());
110 }
111
112 void SVGFontFaceElement::parseAttribute(Attribute* attr)
113 {    
114     int propId = cssPropertyIdForSVGAttributeName(attr->name());
115     if (propId > 0) {
116         m_fontFaceRule->properties()->setProperty(propId, attr->value(), false);
117         rebuildFontFace();
118         return;
119     }
120     
121     SVGElement::parseAttribute(attr);
122 }
123
124 unsigned SVGFontFaceElement::unitsPerEm() const
125 {
126     const AtomicString& value = fastGetAttribute(units_per_emAttr);
127     if (value.isEmpty())
128         return gDefaultUnitsPerEm;
129
130     return static_cast<unsigned>(ceilf(value.toFloat()));
131 }
132
133 int SVGFontFaceElement::xHeight() const
134 {
135     return static_cast<int>(ceilf(fastGetAttribute(x_heightAttr).toFloat()));
136 }
137
138 float SVGFontFaceElement::horizontalOriginX() const
139 {
140     if (!m_fontElement)
141         return 0.0f;
142
143     // Spec: The X-coordinate in the font coordinate system of the origin of a glyph to be used when
144     // drawing horizontally oriented text. (Note that the origin applies to all glyphs in the font.)
145     // If the attribute is not specified, the effect is as if a value of "0" were specified.
146     return m_fontElement->fastGetAttribute(horiz_origin_xAttr).toFloat();
147 }
148
149 float SVGFontFaceElement::horizontalOriginY() const
150 {
151     if (!m_fontElement)
152         return 0.0f;
153
154     // Spec: The Y-coordinate in the font coordinate system of the origin of a glyph to be used when
155     // drawing horizontally oriented text. (Note that the origin applies to all glyphs in the font.)
156     // If the attribute is not specified, the effect is as if a value of "0" were specified.
157     return m_fontElement->fastGetAttribute(horiz_origin_yAttr).toFloat();
158 }
159
160 float SVGFontFaceElement::horizontalAdvanceX() const
161 {
162     if (!m_fontElement)
163         return 0.0f;
164
165     // Spec: The default horizontal advance after rendering a glyph in horizontal orientation. Glyph
166     // widths are required to be non-negative, even if the glyph is typically rendered right-to-left,
167     // as in Hebrew and Arabic scripts.
168     return m_fontElement->fastGetAttribute(horiz_adv_xAttr).toFloat();
169 }
170
171 float SVGFontFaceElement::verticalOriginX() const
172 {
173     if (!m_fontElement)
174         return 0.0f;
175
176     // Spec: The default X-coordinate in the font coordinate system of the origin of a glyph to be used when
177     // drawing vertically oriented text. If the attribute is not specified, the effect is as if the attribute
178     // were set to half of the effective value of attribute horiz-adv-x.
179     const AtomicString& value = m_fontElement->fastGetAttribute(vert_origin_xAttr);
180     if (value.isEmpty())
181         return horizontalAdvanceX() / 2.0f;
182
183     return value.toFloat();
184 }
185
186 float SVGFontFaceElement::verticalOriginY() const
187 {
188     if (!m_fontElement)
189         return 0.0f;
190
191     // Spec: The default Y-coordinate in the font coordinate system of the origin of a glyph to be used when
192     // drawing vertically oriented text. If the attribute is not specified, the effect is as if the attribute
193     // were set to the position specified by the font's ascent attribute.             
194     const AtomicString& value = m_fontElement->fastGetAttribute(vert_origin_yAttr);
195     if (value.isEmpty())
196         return ascent();
197
198     return value.toFloat();
199 }
200
201 float SVGFontFaceElement::verticalAdvanceY() const
202 {
203     if (!m_fontElement)
204         return 0.0f;
205
206     // Spec: The default vertical advance after rendering a glyph in vertical orientation. If the attribute is
207     // not specified, the effect is as if a value equivalent of one em were specified (see units-per-em).                    
208     const AtomicString& value = m_fontElement->fastGetAttribute(vert_adv_yAttr);
209        if (value.isEmpty())
210         return 1.0f;
211
212     return value.toFloat();
213 }
214
215 int SVGFontFaceElement::ascent() const
216 {
217     // Spec: Same syntax and semantics as the 'ascent' descriptor within an @font-face rule. The maximum
218     // unaccented height of the font within the font coordinate system. If the attribute is not specified,
219     // the effect is as if the attribute were set to the difference between the units-per-em value and the
220     // vert-origin-y value for the corresponding font.
221     const AtomicString& ascentValue = fastGetAttribute(ascentAttr);
222     if (!ascentValue.isEmpty())
223         return static_cast<int>(ceilf(ascentValue.toFloat()));
224
225     if (m_fontElement) {
226         const AtomicString& vertOriginY = m_fontElement->fastGetAttribute(vert_origin_yAttr);
227         if (!vertOriginY.isEmpty())
228             return static_cast<int>(unitsPerEm()) - static_cast<int>(ceilf(vertOriginY.toFloat()));
229     }
230
231     // Match Batiks default value
232     return static_cast<int>(ceilf(unitsPerEm() * 0.8f));
233 }
234
235 int SVGFontFaceElement::descent() const
236 {
237     // Spec: Same syntax and semantics as the 'descent' descriptor within an @font-face rule. The maximum
238     // unaccented depth of the font within the font coordinate system. If the attribute is not specified,
239     // the effect is as if the attribute were set to the vert-origin-y value for the corresponding font.
240     const AtomicString& descentValue = fastGetAttribute(descentAttr);
241     if (!descentValue.isEmpty()) {
242         // 14 different W3C SVG 1.1 testcases use a negative descent value,
243         // where a positive was meant to be used  Including:
244         // animate-elem-24-t.svg, fonts-elem-01-t.svg, fonts-elem-02-t.svg (and 11 others)
245         int descent = static_cast<int>(ceilf(descentValue.toFloat()));
246         return descent < 0 ? -descent : descent;
247     }
248
249     if (m_fontElement) {
250         const AtomicString& vertOriginY = m_fontElement->fastGetAttribute(vert_origin_yAttr);
251         if (!vertOriginY.isEmpty())
252             return static_cast<int>(ceilf(vertOriginY.toFloat()));
253     }
254
255     // Match Batiks default value
256     return static_cast<int>(ceilf(unitsPerEm() * 0.2f));
257 }
258
259 String SVGFontFaceElement::fontFamily() const
260 {
261     return m_fontFaceRule->properties()->getPropertyValue(CSSPropertyFontFamily);
262 }
263
264 SVGFontElement* SVGFontFaceElement::associatedFontElement() const
265 {
266     return m_fontElement.get();
267 }
268
269 void SVGFontFaceElement::rebuildFontFace()
270 {
271     if (!inDocument())
272         return;
273
274     // we currently ignore all but the first src element, alternatively we could concat them
275     SVGFontFaceSrcElement* srcElement = 0;
276
277     for (Node* child = firstChild(); child && !srcElement; child = child->nextSibling()) {
278         if (child->hasTagName(font_face_srcTag))
279             srcElement = static_cast<SVGFontFaceSrcElement*>(child);
280     }
281
282     bool describesParentFont = parentNode()->hasTagName(SVGNames::fontTag);
283     RefPtr<CSSValueList> list;
284
285     if (describesParentFont) {
286         m_fontElement = static_cast<SVGFontElement*>(parentNode());
287
288         list = CSSValueList::createCommaSeparated();
289         list->append(CSSFontFaceSrcValue::createLocal(fontFamily()));
290     } else {
291         m_fontElement = 0;
292         if (srcElement)
293             list = srcElement->srcValue();
294     }
295
296     if (!list || !list->length())
297         return;
298
299     // Parse in-memory CSS rules
300     CSSProperty srcProperty(CSSPropertySrc, list);
301     m_fontFaceRule->properties()->addParsedProperties(&srcProperty, 1);
302
303     if (describesParentFont) {    
304         // Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves.
305         RefPtr<CSSValue> src = m_fontFaceRule->properties()->getPropertyCSSValue(CSSPropertySrc);
306         CSSValueList* srcList = static_cast<CSSValueList*>(src.get());
307
308         unsigned srcLength = srcList ? srcList->length() : 0;
309         for (unsigned i = 0; i < srcLength; i++) {
310             if (CSSFontFaceSrcValue* item = static_cast<CSSFontFaceSrcValue*>(srcList->itemWithoutBoundsCheck(i)))
311                 item->setSVGFontFaceElement(this);
312         }
313     }
314
315     document()->styleSelectorChanged(DeferRecalcStyle);
316 }
317
318 void SVGFontFaceElement::insertedIntoDocument()
319 {
320     SVGElement::insertedIntoDocument();
321
322     document()->accessSVGExtensions()->registerSVGFontFaceElement(this);
323
324     rebuildFontFace();
325 }
326
327 void SVGFontFaceElement::removedFromDocument()
328 {
329     SVGElement::removedFromDocument();
330
331     document()->accessSVGExtensions()->unregisterSVGFontFaceElement(this);
332     m_fontFaceRule->properties()->parseDeclaration(emptyString(), 0);
333
334     document()->styleSelectorChanged(DeferRecalcStyle);
335 }
336
337 void SVGFontFaceElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
338 {
339     SVGElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
340     rebuildFontFace();
341 }
342
343 } // namespace WebCore
344
345 #endif // ENABLE(SVG_FONTS)