Clean up ContainerNode::childrenChanged
[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 "CSSPropertyNames.h"
31 #include "CSSStyleSheet.h"
32 #include "CSSValueKeywords.h"
33 #include "CSSValueList.h"
34 #include "Document.h"
35 #include "Font.h"
36 #include "SVGDocumentExtensions.h"
37 #include "SVGFontElement.h"
38 #include "SVGFontFaceSrcElement.h"
39 #include "SVGGlyphElement.h"
40 #include "SVGNames.h"
41 #include "StylePropertySet.h"
42 #include "StyleResolver.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(MutableStylePropertySet::create(CSSStrictMode)))
53     , m_fontElement(0)
54 {
55     ASSERT(hasTagName(font_faceTag));
56 }
57
58 PassRefPtr<SVGFontFaceElement> SVGFontFaceElement::create(const QualifiedName& tagName, Document* document)
59 {
60     return adoptRef(new SVGFontFaceElement(tagName, document));
61 }
62
63 void SVGFontFaceElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
64 {    
65     CSSPropertyID propId = cssPropertyIdForSVGAttributeName(name);
66     if (propId > 0) {
67         m_fontFaceRule->mutableProperties()->setProperty(propId, value, false);
68         rebuildFontFace();
69         return;
70     }
71     
72     SVGElement::parseAttribute(name, value);
73 }
74
75 unsigned SVGFontFaceElement::unitsPerEm() const
76 {
77     const AtomicString& value = fastGetAttribute(units_per_emAttr);
78     if (value.isEmpty())
79         return gDefaultUnitsPerEm;
80
81     return static_cast<unsigned>(ceilf(value.toFloat()));
82 }
83
84 int SVGFontFaceElement::xHeight() const
85 {
86     return static_cast<int>(ceilf(fastGetAttribute(x_heightAttr).toFloat()));
87 }
88
89 float SVGFontFaceElement::horizontalOriginX() const
90 {
91     if (!m_fontElement)
92         return 0.0f;
93
94     // Spec: The X-coordinate in the font coordinate system of the origin of a glyph to be used when
95     // drawing horizontally oriented text. (Note that the origin applies to all glyphs in the font.)
96     // If the attribute is not specified, the effect is as if a value of "0" were specified.
97     return m_fontElement->fastGetAttribute(horiz_origin_xAttr).toFloat();
98 }
99
100 float SVGFontFaceElement::horizontalOriginY() const
101 {
102     if (!m_fontElement)
103         return 0.0f;
104
105     // Spec: The Y-coordinate in the font coordinate system of the origin of a glyph to be used when
106     // drawing horizontally oriented text. (Note that the origin applies to all glyphs in the font.)
107     // If the attribute is not specified, the effect is as if a value of "0" were specified.
108     return m_fontElement->fastGetAttribute(horiz_origin_yAttr).toFloat();
109 }
110
111 float SVGFontFaceElement::horizontalAdvanceX() const
112 {
113     if (!m_fontElement)
114         return 0.0f;
115
116     // Spec: The default horizontal advance after rendering a glyph in horizontal orientation. Glyph
117     // widths are required to be non-negative, even if the glyph is typically rendered right-to-left,
118     // as in Hebrew and Arabic scripts.
119     return m_fontElement->fastGetAttribute(horiz_adv_xAttr).toFloat();
120 }
121
122 float SVGFontFaceElement::verticalOriginX() const
123 {
124     if (!m_fontElement)
125         return 0.0f;
126
127     // Spec: The default X-coordinate in the font coordinate system of the origin of a glyph to be used when
128     // drawing vertically oriented text. If the attribute is not specified, the effect is as if the attribute
129     // were set to half of the effective value of attribute horiz-adv-x.
130     const AtomicString& value = m_fontElement->fastGetAttribute(vert_origin_xAttr);
131     if (value.isEmpty())
132         return horizontalAdvanceX() / 2.0f;
133
134     return value.toFloat();
135 }
136
137 float SVGFontFaceElement::verticalOriginY() const
138 {
139     if (!m_fontElement)
140         return 0.0f;
141
142     // Spec: The default Y-coordinate in the font coordinate system of the origin of a glyph to be used when
143     // drawing vertically oriented text. If the attribute is not specified, the effect is as if the attribute
144     // were set to the position specified by the font's ascent attribute.             
145     const AtomicString& value = m_fontElement->fastGetAttribute(vert_origin_yAttr);
146     if (value.isEmpty())
147         return ascent();
148
149     return value.toFloat();
150 }
151
152 float SVGFontFaceElement::verticalAdvanceY() const
153 {
154     if (!m_fontElement)
155         return 0.0f;
156
157     // Spec: The default vertical advance after rendering a glyph in vertical orientation. If the attribute is
158     // not specified, the effect is as if a value equivalent of one em were specified (see units-per-em).                    
159     const AtomicString& value = m_fontElement->fastGetAttribute(vert_adv_yAttr);
160        if (value.isEmpty())
161         return 1.0f;
162
163     return value.toFloat();
164 }
165
166 int SVGFontFaceElement::ascent() const
167 {
168     // Spec: Same syntax and semantics as the 'ascent' descriptor within an @font-face rule. The maximum
169     // unaccented height of the font within the font coordinate system. If the attribute is not specified,
170     // the effect is as if the attribute were set to the difference between the units-per-em value and the
171     // vert-origin-y value for the corresponding font.
172     const AtomicString& ascentValue = fastGetAttribute(ascentAttr);
173     if (!ascentValue.isEmpty())
174         return static_cast<int>(ceilf(ascentValue.toFloat()));
175
176     if (m_fontElement) {
177         const AtomicString& vertOriginY = m_fontElement->fastGetAttribute(vert_origin_yAttr);
178         if (!vertOriginY.isEmpty())
179             return static_cast<int>(unitsPerEm()) - static_cast<int>(ceilf(vertOriginY.toFloat()));
180     }
181
182     // Match Batiks default value
183     return static_cast<int>(ceilf(unitsPerEm() * 0.8f));
184 }
185
186 int SVGFontFaceElement::descent() const
187 {
188     // Spec: Same syntax and semantics as the 'descent' descriptor within an @font-face rule. The maximum
189     // unaccented depth of the font within the font coordinate system. If the attribute is not specified,
190     // the effect is as if the attribute were set to the vert-origin-y value for the corresponding font.
191     const AtomicString& descentValue = fastGetAttribute(descentAttr);
192     if (!descentValue.isEmpty()) {
193         // 14 different W3C SVG 1.1 testcases use a negative descent value,
194         // where a positive was meant to be used  Including:
195         // animate-elem-24-t.svg, fonts-elem-01-t.svg, fonts-elem-02-t.svg (and 11 others)
196         int descent = static_cast<int>(ceilf(descentValue.toFloat()));
197         return descent < 0 ? -descent : descent;
198     }
199
200     if (m_fontElement) {
201         const AtomicString& vertOriginY = m_fontElement->fastGetAttribute(vert_origin_yAttr);
202         if (!vertOriginY.isEmpty())
203             return static_cast<int>(ceilf(vertOriginY.toFloat()));
204     }
205
206     // Match Batiks default value
207     return static_cast<int>(ceilf(unitsPerEm() * 0.2f));
208 }
209
210 String SVGFontFaceElement::fontFamily() const
211 {
212     return m_fontFaceRule->properties().getPropertyValue(CSSPropertyFontFamily);
213 }
214
215 SVGFontElement* SVGFontFaceElement::associatedFontElement() const
216 {
217     ASSERT(parentNode() == m_fontElement);
218     ASSERT(!parentNode() || isSVGFontElement(parentNode()));
219     return m_fontElement;
220 }
221
222 void SVGFontFaceElement::rebuildFontFace()
223 {
224     if (!inDocument()) {
225         ASSERT(!m_fontElement);
226         return;
227     }
228
229     // we currently ignore all but the first src element, alternatively we could concat them
230     SVGFontFaceSrcElement* srcElement = 0;
231
232     for (Node* child = firstChild(); child && !srcElement; child = child->nextSibling()) {
233         if (child->hasTagName(font_face_srcTag))
234             srcElement = static_cast<SVGFontFaceSrcElement*>(child);
235     }
236
237     bool describesParentFont = isSVGFontElement(parentNode());
238     RefPtr<CSSValueList> list;
239
240     if (describesParentFont) {
241         m_fontElement = toSVGFontElement(parentNode());
242
243         list = CSSValueList::createCommaSeparated();
244         list->append(CSSFontFaceSrcValue::createLocal(fontFamily()));
245     } else {
246         m_fontElement = 0;
247         if (srcElement)
248             list = srcElement->srcValue();
249     }
250
251     if (!list || !list->length())
252         return;
253
254     // Parse in-memory CSS rules
255     m_fontFaceRule->mutableProperties()->addParsedProperty(CSSProperty(CSSPropertySrc, list));
256
257     if (describesParentFont) {    
258         // Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves.
259         RefPtr<CSSValue> src = m_fontFaceRule->properties().getPropertyCSSValue(CSSPropertySrc);
260         CSSValueList* srcList = static_cast<CSSValueList*>(src.get());
261
262         unsigned srcLength = srcList ? srcList->length() : 0;
263         for (unsigned i = 0; i < srcLength; i++) {
264             if (CSSFontFaceSrcValue* item = static_cast<CSSFontFaceSrcValue*>(srcList->itemWithoutBoundsCheck(i)))
265                 item->setSVGFontFaceElement(this);
266         }
267     }
268
269     document().styleResolverChanged(DeferRecalcStyle);
270 }
271
272 Node::InsertionNotificationRequest SVGFontFaceElement::insertedInto(ContainerNode* rootParent)
273 {
274     SVGElement::insertedInto(rootParent);
275     if (!rootParent->inDocument()) {
276         ASSERT(!m_fontElement);
277         return InsertionDone;
278     }
279     document().accessSVGExtensions()->registerSVGFontFaceElement(this);
280
281     rebuildFontFace();
282     return InsertionDone;
283 }
284
285 void SVGFontFaceElement::removedFrom(ContainerNode* rootParent)
286 {
287     SVGElement::removedFrom(rootParent);
288
289     if (rootParent->inDocument()) {
290         m_fontElement = 0;
291         document().accessSVGExtensions()->unregisterSVGFontFaceElement(this);
292         m_fontFaceRule->mutableProperties()->clear();
293
294         document().styleResolverChanged(DeferRecalcStyle);
295     } else
296         ASSERT(!m_fontElement);
297 }
298
299 void SVGFontFaceElement::childrenChanged(const ChildChange& change)
300 {
301     SVGElement::childrenChanged(change);
302     rebuildFontFace();
303 }
304
305 } // namespace WebCore
306
307 #endif // ENABLE(SVG_FONTS)