994b084a14c57a4a464895ce4811913540a793bc
[WebKit-https.git] / WebCore / dom / StyledElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Peter Kelly (pmk@post.com)
5  *           (C) 2001 Dirk Mueller (mueller@kde.org)
6  * Copyright (C) 2004, 2005, 2006, 2008, 2010 Apple Inc. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "StyledElement.h"
26
27 #include "Attribute.h"
28 #include "CSSStyleSelector.h"
29 #include "CSSStyleSheet.h"
30 #include "CSSValueKeywords.h"
31 #include "Document.h"
32 #include "HTMLNames.h"
33 #include <wtf/HashFunctions.h>
34
35 using namespace std;
36
37 namespace WebCore {
38
39 using namespace HTMLNames;
40
41 struct MappedAttributeKey {
42     uint16_t type;
43     StringImpl* name;
44     StringImpl* value;
45     MappedAttributeKey(MappedAttributeEntry t = eNone, StringImpl* n = 0, StringImpl* v = 0)
46         : type(t), name(n), value(v) { }
47 };
48
49 static inline bool operator==(const MappedAttributeKey& a, const MappedAttributeKey& b)
50     { return a.type == b.type && a.name == b.name && a.value == b.value; } 
51
52 struct MappedAttributeKeyTraits : WTF::GenericHashTraits<MappedAttributeKey> {
53     static const bool emptyValueIsZero = true;
54     static const bool needsDestruction = false;
55     static void constructDeletedValue(MappedAttributeKey& slot) { slot.type = eLastEntry; }
56     static bool isDeletedValue(const MappedAttributeKey& value) { return value.type == eLastEntry; }
57 };
58
59 struct MappedAttributeHash {
60     static unsigned hash(const MappedAttributeKey&);
61     static bool equal(const MappedAttributeKey& a, const MappedAttributeKey& b) { return a == b; }
62     static const bool safeToCompareToEmptyOrDeleted = true;
63 };
64
65 typedef HashMap<MappedAttributeKey, CSSMappedAttributeDeclaration*, MappedAttributeHash, MappedAttributeKeyTraits> MappedAttributeDecls;
66
67 static MappedAttributeDecls* mappedAttributeDecls = 0;
68
69 CSSMappedAttributeDeclaration* StyledElement::getMappedAttributeDecl(MappedAttributeEntry entryType, Attribute* attr)
70 {
71     if (!mappedAttributeDecls)
72         return 0;
73     return mappedAttributeDecls->get(MappedAttributeKey(entryType, attr->name().localName().impl(), attr->value().impl()));
74 }
75
76 CSSMappedAttributeDeclaration* StyledElement::getMappedAttributeDecl(MappedAttributeEntry type, const QualifiedName& name, const AtomicString& value)
77 {
78     if (!mappedAttributeDecls)
79         return 0;
80     return mappedAttributeDecls->get(MappedAttributeKey(type, name.localName().impl(), value.impl()));
81 }
82
83 void StyledElement::setMappedAttributeDecl(MappedAttributeEntry entryType, Attribute* attr, CSSMappedAttributeDeclaration* decl)
84 {
85     if (!mappedAttributeDecls)
86         mappedAttributeDecls = new MappedAttributeDecls;
87     mappedAttributeDecls->set(MappedAttributeKey(entryType, attr->name().localName().impl(), attr->value().impl()), decl);
88 }
89
90 void StyledElement::setMappedAttributeDecl(MappedAttributeEntry entryType, const QualifiedName& name, const AtomicString& value, CSSMappedAttributeDeclaration* decl)
91 {
92     if (!mappedAttributeDecls)
93         mappedAttributeDecls = new MappedAttributeDecls;
94     mappedAttributeDecls->set(MappedAttributeKey(entryType, name.localName().impl(), value.impl()), decl);
95 }
96
97 void StyledElement::removeMappedAttributeDecl(MappedAttributeEntry entryType, const QualifiedName& attrName, const AtomicString& attrValue)
98 {
99     if (!mappedAttributeDecls)
100         return;
101     mappedAttributeDecls->remove(MappedAttributeKey(entryType, attrName.localName().impl(), attrValue.impl()));
102 }
103
104 void StyledElement::updateStyleAttribute() const
105 {
106     ASSERT(!isStyleAttributeValid());
107     setIsStyleAttributeValid();
108     setIsSynchronizingStyleAttribute();
109     if (m_inlineStyleDecl)
110         const_cast<StyledElement*>(this)->setAttribute(styleAttr, m_inlineStyleDecl->cssText());
111     clearIsSynchronizingStyleAttribute();
112 }
113
114 StyledElement::~StyledElement()
115 {
116     destroyInlineStyleDecl();
117 }
118
119 PassRefPtr<Attribute> StyledElement::createAttribute(const QualifiedName& name, const AtomicString& value)
120 {
121     return Attribute::createMapped(name, value);
122 }
123
124 void StyledElement::createInlineStyleDecl()
125 {
126     m_inlineStyleDecl = CSSMutableStyleDeclaration::create();
127     m_inlineStyleDecl->setParent(document()->elementSheet());
128     m_inlineStyleDecl->setNode(this);
129     m_inlineStyleDecl->setStrictParsing(isHTMLElement() && !document()->inCompatMode());
130 }
131
132 void StyledElement::destroyInlineStyleDecl()
133 {
134     if (m_inlineStyleDecl) {
135         m_inlineStyleDecl->setNode(0);
136         m_inlineStyleDecl->setParent(0);
137         m_inlineStyleDecl = 0;
138     }
139 }
140
141 void StyledElement::attributeChanged(Attribute* attr, bool preserveDecls)
142 {
143     if (!attr->isMappedAttribute()) {
144         Element::attributeChanged(attr, preserveDecls);
145         return;
146     }
147  
148     if (attr->decl() && !preserveDecls) {
149         attr->setDecl(0);
150         setNeedsStyleRecalc();
151         if (namedAttrMap)
152             mappedAttributes()->declRemoved();
153     }
154
155     bool checkDecl = true;
156     MappedAttributeEntry entry;
157     bool needToParse = mapToEntry(attr->name(), entry);
158     if (preserveDecls) {
159         if (attr->decl()) {
160             setNeedsStyleRecalc();
161             if (namedAttrMap)
162                 mappedAttributes()->declAdded();
163             checkDecl = false;
164         }
165     } else if (!attr->isNull() && entry != eNone) {
166         CSSMappedAttributeDeclaration* decl = getMappedAttributeDecl(entry, attr);
167         if (decl) {
168             attr->setDecl(decl);
169             setNeedsStyleRecalc();
170             if (namedAttrMap)
171                 mappedAttributes()->declAdded();
172             checkDecl = false;
173         } else
174             needToParse = true;
175     }
176
177     // parseMappedAttribute() might create a CSSMappedAttributeDeclaration on the attribute.  
178     // Normally we would be concerned about reseting the parent of those declarations in StyledElement::didMoveToNewOwnerDocument().
179     // But currently we always clear its parent and node below when adding it to the decl table.  
180     // If that changes for some reason moving between documents will be buggy.
181     // webarchive/adopt-attribute-styled-node-webarchive.html should catch any resulting crashes.
182     if (needToParse)
183         parseMappedAttribute(attr);
184
185     if (entry == eNone)
186         recalcStyleIfNeededAfterAttributeChanged(attr);
187
188     if (checkDecl && attr->decl()) {
189         // Add the decl to the table in the appropriate spot.
190         setMappedAttributeDecl(entry, attr, attr->decl());
191         attr->decl()->setMappedState(entry, attr->name(), attr->value());
192         attr->decl()->setParent(0);
193         attr->decl()->setNode(0);
194         if (namedAttrMap)
195             mappedAttributes()->declAdded();
196     }
197
198     updateAfterAttributeChanged(attr);
199 }
200
201 bool StyledElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
202 {
203     result = eNone;
204     if (attrName == styleAttr)
205         return !isSynchronizingStyleAttribute();
206     return true;
207 }
208
209 void StyledElement::classAttributeChanged(const AtomicString& newClassString)
210 {
211     const UChar* characters = newClassString.characters();
212     unsigned length = newClassString.length();
213     unsigned i;
214     for (i = 0; i < length; ++i) {
215         if (!isClassWhitespace(characters[i]))
216             break;
217     }
218     setHasClass(i < length);
219     if (namedAttrMap) {
220         if (i < length)
221             mappedAttributes()->setClass(newClassString);
222         else
223             mappedAttributes()->clearClass();
224     }
225     setNeedsStyleRecalc();
226     dispatchSubtreeModifiedEvent();
227 }
228
229 void StyledElement::parseMappedAttribute(Attribute* attr)
230 {
231     if (isIdAttributeName(attr->name())) {
232         setHasID(!attr->isNull());
233         if (namedAttrMap) {
234             if (attr->isNull())
235                 namedAttrMap->setIdForStyleResolution(nullAtom);
236             else if (document()->inCompatMode())
237                 namedAttrMap->setIdForStyleResolution(attr->value().lower());
238             else
239                 namedAttrMap->setIdForStyleResolution(attr->value());
240         }
241         setNeedsStyleRecalc();
242     } else if (attr->name() == classAttr)
243         classAttributeChanged(attr->value());
244     else if (attr->name() == styleAttr) {
245         if (attr->isNull())
246             destroyInlineStyleDecl();
247         else
248             getInlineStyleDecl()->parseDeclaration(attr->value());
249         setIsStyleAttributeValid();
250         setNeedsStyleRecalc();
251     }
252 }
253
254 CSSMutableStyleDeclaration* StyledElement::getInlineStyleDecl()
255 {
256     if (!m_inlineStyleDecl)
257         createInlineStyleDecl();
258     return m_inlineStyleDecl.get();
259 }
260
261 CSSStyleDeclaration* StyledElement::style()
262 {
263     return getInlineStyleDecl();
264 }
265
266 void StyledElement::addCSSProperty(Attribute* attr, int id, const String &value)
267 {
268     if (!attr->decl()) createMappedDecl(attr);
269     attr->decl()->setProperty(id, value, false);
270 }
271
272 void StyledElement::addCSSProperty(Attribute* attr, int id, int value)
273 {
274     if (!attr->decl()) createMappedDecl(attr);
275     attr->decl()->setProperty(id, value, false);
276 }
277
278 void StyledElement::addCSSImageProperty(Attribute* attr, int id, const String& url)
279 {
280     if (!attr->decl()) createMappedDecl(attr);
281     attr->decl()->setImageProperty(id, url, false);
282 }
283
284 void StyledElement::addCSSLength(Attribute* attr, int id, const String &value)
285 {
286     // FIXME: This function should not spin up the CSS parser, but should instead just figure out the correct
287     // length unit and make the appropriate parsed value.
288     if (!attr->decl())
289         createMappedDecl(attr);
290
291     // strip attribute garbage..
292     StringImpl* v = value.impl();
293     if (v) {
294         unsigned int l = 0;
295         
296         while (l < v->length() && (*v)[l] <= ' ')
297             l++;
298         
299         for (; l < v->length(); l++) {
300             UChar cc = (*v)[l];
301             if (cc > '9')
302                 break;
303             if (cc < '0') {
304                 if (cc == '%' || cc == '*')
305                     l++;
306                 if (cc != '.')
307                     break;
308             }
309         }
310
311         if (l != v->length()) {
312             attr->decl()->setLengthProperty(id, v->substring(0, l), false);
313             return;
314         }
315     }
316     
317     attr->decl()->setLengthProperty(id, value, false);
318 }
319
320 /* color parsing that tries to match as close as possible IE 6. */
321 void StyledElement::addCSSColor(Attribute* attr, int id, const String& c)
322 {
323     // this is the only case no color gets applied in IE.
324     if (!c.length())
325         return;
326
327     if (!attr->decl())
328         createMappedDecl(attr);
329     
330     if (attr->decl()->setProperty(id, c, false))
331         return;
332     
333     String color = c;
334     // not something that fits the specs.
335     
336     // we're emulating IEs color parser here. It maps transparent to black, otherwise it tries to build a rgb value
337     // out of everything you put in. The algorithm is experimentally determined, but seems to work for all test cases I have.
338     
339     // the length of the color value is rounded up to the next
340     // multiple of 3. each part of the rgb triple then gets one third
341     // of the length.
342     //
343     // Each triplet is parsed byte by byte, mapping
344     // each number to a hex value (0-9a-fA-F to their values
345     // everything else to 0).
346     //
347     // The highest non zero digit in all triplets is remembered, and
348     // used as a normalization point to normalize to values between 0
349     // and 255.
350     
351     if (!equalIgnoringCase(color, "transparent")) {
352         if (color[0] == '#')
353             color.remove(0, 1);
354         int basicLength = (color.length() + 2) / 3;
355         if (basicLength > 1) {
356             // IE ignores colors with three digits or less
357             int colors[3] = { 0, 0, 0 };
358             int component = 0;
359             int pos = 0;
360             int maxDigit = basicLength-1;
361             while (component < 3) {
362                 // search forward for digits in the string
363                 int numDigits = 0;
364                 while (pos < (int)color.length() && numDigits < basicLength) {
365                     colors[component] <<= 4;
366                     if (isASCIIHexDigit(color[pos])) {
367                         colors[component] += toASCIIHexValue(color[pos]);
368                         maxDigit = min(maxDigit, numDigits);
369                     }
370                     numDigits++;
371                     pos++;
372                 }
373                 while (numDigits++ < basicLength)
374                     colors[component] <<= 4;
375                 component++;
376             }
377             maxDigit = basicLength - maxDigit;
378             
379             // normalize to 00-ff. The highest filled digit counts, minimum is 2 digits
380             maxDigit -= 2;
381             colors[0] >>= 4 * maxDigit;
382             colors[1] >>= 4 * maxDigit;
383             colors[2] >>= 4 * maxDigit;
384             
385             color = String::format("#%02x%02x%02x", colors[0], colors[1], colors[2]);
386             if (attr->decl()->setProperty(id, color, false))
387                 return;
388         }
389     }
390     attr->decl()->setProperty(id, CSSValueBlack, false);
391 }
392
393 void StyledElement::createMappedDecl(Attribute* attr)
394 {
395     RefPtr<CSSMappedAttributeDeclaration> decl = CSSMappedAttributeDeclaration::create();
396     attr->setDecl(decl);
397     decl->setParent(document()->elementSheet());
398     decl->setNode(this);
399     decl->setStrictParsing(false); // Mapped attributes are just always quirky.
400 }
401
402 // Paul Hsieh's SuperFastHash
403 // http://www.azillionmonkeys.com/qed/hash.html
404 unsigned MappedAttributeHash::hash(const MappedAttributeKey& key)
405 {
406     uint32_t hash = WTF::stringHashingStartValue;
407     uint32_t tmp;
408
409     const uint16_t* p;
410
411     p = reinterpret_cast<const uint16_t*>(&key.name);
412     hash += p[0];
413     tmp = (p[1] << 11) ^ hash;
414     hash = (hash << 16) ^ tmp;
415     hash += hash >> 11;
416     ASSERT(sizeof(key.name) == 4 || sizeof(key.name) == 8);
417     if (sizeof(key.name) == 8) {
418         p += 2;
419         hash += p[0];
420         tmp = (p[1] << 11) ^ hash;
421         hash = (hash << 16) ^ tmp;
422         hash += hash >> 11;
423     }
424
425     p = reinterpret_cast<const uint16_t*>(&key.value);
426     hash += p[0];
427     tmp = (p[1] << 11) ^ hash;
428     hash = (hash << 16) ^ tmp;
429     hash += hash >> 11;
430     ASSERT(sizeof(key.value) == 4 || sizeof(key.value) == 8);
431     if (sizeof(key.value) == 8) {
432         p += 2;
433         hash += p[0];
434         tmp = (p[1] << 11) ^ hash;
435         hash = (hash << 16) ^ tmp;
436         hash += hash >> 11;
437     }
438
439     // Handle end case
440     hash += key.type;
441     hash ^= hash << 11;
442     hash += hash >> 17;
443
444     // Force "avalanching" of final 127 bits
445     hash ^= hash << 3;
446     hash += hash >> 5;
447     hash ^= hash << 2;
448     hash += hash >> 15;
449     hash ^= hash << 10;
450
451     // This avoids ever returning a hash code of 0, since that is used to
452     // signal "hash not computed yet", using a value that is likely to be
453     // effectively the same as 0 when the low bits are masked
454     if (hash == 0)
455         hash = 0x80000000;
456
457     return hash;
458 }
459
460 void StyledElement::copyNonAttributeProperties(const Element *sourceElement)
461 {
462     const StyledElement* source = static_cast<const StyledElement*>(sourceElement);
463     if (!source->m_inlineStyleDecl)
464         return;
465
466     *getInlineStyleDecl() = *source->m_inlineStyleDecl;
467     setIsStyleAttributeValid(source->isStyleAttributeValid());
468     setIsSynchronizingStyleAttribute(source->isSynchronizingStyleAttribute());
469     
470     Element::copyNonAttributeProperties(sourceElement);
471 }
472
473 void StyledElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
474 {
475     if (CSSMutableStyleDeclaration* style = inlineStyleDecl())
476         style->addSubresourceStyleURLs(urls);
477 }
478
479
480 void StyledElement::didMoveToNewOwnerDocument()
481 {
482     if (m_inlineStyleDecl)
483         m_inlineStyleDecl->setParent(document()->elementSheet());
484
485     Element::didMoveToNewOwnerDocument();
486 }
487
488 }