2010-09-09 Dirk Pranke <dpranke@chromium.org>
[WebKit.git] / WebCore / css / CSSStyleSelector.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #ifndef CSSStyleSelector_h
23 #define CSSStyleSelector_h
24
25 #include "CSSFontSelector.h"
26 #include "LinkHash.h"
27 #include "MediaQueryExp.h"
28 #include "RenderStyle.h"
29 #include <wtf/HashMap.h>
30 #include <wtf/HashSet.h>
31 #include <wtf/RefPtr.h>
32 #include <wtf/Vector.h>
33 #include <wtf/text/StringHash.h>
34
35 namespace WebCore {
36
37 class CSSMutableStyleDeclaration;
38 class CSSPageRule;
39 class CSSPrimitiveValue;
40 class CSSProperty;
41 class CSSFontFace;
42 class CSSFontFaceRule;
43 class CSSImageValue;
44 class CSSRuleData;
45 class CSSRuleDataList;
46 class CSSRuleList;
47 class CSSRuleSet;
48 class CSSSelector;
49 class CSSStyleRule;
50 class CSSStyleSheet;
51 class CSSValue;
52 class CSSVariableDependentValue;
53 class CSSVariablesRule;
54 class ContainerNode;
55 class DataGridColumn;
56 class Document;
57 class Element;
58 class Frame;
59 class FrameView;
60 class KURL;
61 class KeyframeList;
62 class KeyframeValue;
63 class MediaQueryEvaluator;
64 class Node;
65 class Settings;
66 class StyleImage;
67 class StyleSheet;
68 class StyleSheetList;
69 class StyledElement;
70 class WebKitCSSKeyframeRule;
71 class WebKitCSSKeyframesRule;
72
73 class MediaQueryResult : public Noncopyable {
74 public:
75     MediaQueryResult(const MediaQueryExp& expr, bool result)
76         : m_expression(expr)
77         , m_result(result)
78     {
79     }
80
81     MediaQueryExp m_expression;
82     bool m_result;
83 };
84
85     // This class selects a RenderStyle for a given element based on a collection of stylesheets.
86     class CSSStyleSelector : public Noncopyable {
87     public:
88         CSSStyleSelector(Document*, StyleSheetList* authorSheets, CSSStyleSheet* mappedElementSheet,
89                          CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets,
90                          bool strictParsing, bool matchAuthorAndUserStyles);
91         ~CSSStyleSelector();
92
93         PassRefPtr<RenderStyle> styleForElement(Element* e, RenderStyle* parentStyle = 0, bool allowSharing = true, bool resolveForRootDefault = false, bool matchVisitedPseudoClass = false);
94         
95         void keyframeStylesForAnimation(Element*, const RenderStyle*, KeyframeList& list);
96
97         PassRefPtr<RenderStyle> pseudoStyleForElement(PseudoId pseudo, Element* e, RenderStyle* parentStyle = 0, bool matchVisitedPseudoClass = false);
98
99         PassRefPtr<RenderStyle> styleForPage(int pageIndex);
100
101         static PassRefPtr<RenderStyle> styleForDocument(Document*);
102
103 #if ENABLE(DATAGRID)
104         // Datagrid style computation (uses unique pseudo elements and structures)
105         PassRefPtr<RenderStyle> pseudoStyleForDataGridColumn(DataGridColumn*, RenderStyle* parentStyle);
106         PassRefPtr<RenderStyle> pseudoStyleForDataGridColumnHeader(DataGridColumn*, RenderStyle* parentStyle);
107 #endif
108
109     private:
110         void initForStyleResolve(Element*, RenderStyle* parentStyle = 0, PseudoId = NOPSEUDO);
111         void initElement(Element*);
112         RenderStyle* locateSharedStyle();
113         Node* locateCousinList(Element* parent, unsigned depth = 1);
114         bool canShareStyleWithElement(Node*);
115
116         RenderStyle* style() const { return m_style.get(); }
117
118         PassRefPtr<RenderStyle> styleForKeyframe(const RenderStyle*, const WebKitCSSKeyframeRule*, KeyframeValue&);
119
120     public:
121         // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
122         PassRefPtr<CSSRuleList> styleRulesForElement(Element*, bool authorOnly);
123         PassRefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, PseudoId, bool authorOnly);
124
125         // Given a font size in pixel, this function will return legacy font size between 1 and 7.
126         static int legacyFontSize(Document*, int pixelFontSize, bool shouldUseFixedDefaultSize);
127
128     private:
129         // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
130         // the correct font size scaled relative to the user's default (medium).
131         static float fontSizeForKeyword(Document*, int keyword, bool shouldUseFixedDefaultSize);
132
133         // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
134         // table, and failing that, will simply multiply by 1.2.
135         float largerFontSize(float size, bool quirksMode) const;
136
137         // Like the previous function, but for the keyword "smaller".
138         float smallerFontSize(float size, bool quirksMode) const;
139
140     public:
141         void setStyle(PassRefPtr<RenderStyle> s) { m_style = s; } // Used by the document when setting up its root style.
142
143         void applyPropertyToStyle(int id, CSSValue*, RenderStyle*);
144
145     private:
146         void setFontSize(FontDescription&, float size);
147         static float getComputedSizeFromSpecifiedSize(Document*, RenderStyle*, bool isAbsoluteSize, float specifiedSize, bool useSVGZoomRules);
148
149     public:
150         Color getColorFromPrimitiveValue(CSSPrimitiveValue*);
151
152         bool hasSelectorForAttribute(const AtomicString&);
153  
154         CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
155
156         // Checks if a compound selector (which can consist of multiple simple selectors) matches the current element.
157         bool checkSelector(CSSSelector*);
158
159         void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
160
161         bool affectedByViewportChange() const;
162
163         void allVisitedStateChanged() { m_checker.allVisitedStateChanged(); }
164         void visitedStateChanged(LinkHash visitedHash) { m_checker.visitedStateChanged(visitedHash); }
165
166         void addVariables(CSSVariablesRule* variables);
167         CSSValue* resolveVariableDependentValue(CSSVariableDependentValue*);
168         void resolveVariablesForDeclaration(CSSMutableStyleDeclaration* decl, CSSMutableStyleDeclaration* newDecl, HashSet<String>& usedBlockVariables);
169
170         void addKeyframeStyle(PassRefPtr<WebKitCSSKeyframesRule> rule);
171         void addPageStyle(PassRefPtr<CSSPageRule>);
172
173         static bool createTransformOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, TransformOperations& outOperations);
174
175     private:
176         enum SelectorMatch { SelectorMatches, SelectorFailsLocally, SelectorFailsCompletely };
177
178         // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
179         void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
180         void checkForZoomChange(RenderStyle*, RenderStyle* parentStyle);
181         void checkForTextSizeAdjust();
182
183         void adjustRenderStyle(RenderStyle*, Element*);
184
185         void addMatchedRule(CSSRuleData* rule) { m_matchedRules.append(rule); }
186         void addMatchedDeclaration(CSSMutableStyleDeclaration* decl);
187
188         void matchRules(CSSRuleSet*, int& firstRuleIndex, int& lastRuleIndex);
189         void matchRulesForList(CSSRuleDataList*, int& firstRuleIndex, int& lastRuleIndex);
190         void sortMatchedRules(unsigned start, unsigned end);
191
192         template <bool firstPass>
193         void applyDeclarations(bool important, int startIndex, int endIndex);
194
195         void matchPageRules(CSSRuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
196         void matchPageRulesForList(CSSRuleDataList*, bool isLeftPage, bool isFirstPage, const String& pageName);
197         bool isLeftPage(int pageIndex) const;
198         bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
199         bool isFirstPage(int pageIndex) const;
200         String pageName(int pageIndex) const;
201         
202         OwnPtr<CSSRuleSet> m_authorStyle;
203         OwnPtr<CSSRuleSet> m_userStyle;
204
205         bool m_hasUAAppearance;
206         BorderData m_borderData;
207         FillLayer m_backgroundData;
208         Color m_backgroundColor;
209
210         typedef HashMap<AtomicStringImpl*, RefPtr<WebKitCSSKeyframesRule> > KeyframesRuleMap;
211         KeyframesRuleMap m_keyframesRuleMap;
212
213     public:
214         static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
215
216         class SelectorChecker : public Noncopyable {
217         public:
218             SelectorChecker(Document*, bool strictParsing);
219
220             bool checkSelector(CSSSelector*, Element*) const;
221             SelectorMatch checkSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, bool encounteredLink, RenderStyle* = 0, RenderStyle* elementParentStyle = 0) const;
222             bool checkOneSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, RenderStyle*, RenderStyle* elementParentStyle) const;
223             bool checkScrollbarPseudoClass(CSSSelector*, PseudoId& dynamicPseudo) const;
224
225             EInsideLink determineLinkState(Element* element) const;
226             EInsideLink determineLinkStateSlowCase(Element* element) const;
227             void allVisitedStateChanged();
228             void visitedStateChanged(LinkHash visitedHash);
229
230             Document* m_document;
231             bool m_strictParsing;
232             bool m_collectRulesOnly;
233             PseudoId m_pseudoStyle;
234             bool m_documentIsHTML;
235             mutable bool m_matchVisitedPseudoClass;
236             mutable HashSet<LinkHash, LinkHashHash> m_linksCheckedForVisitedState;
237         };
238
239     private:
240         static RenderStyle* s_styleNotYetAvailable;
241
242         void matchUARules(int& firstUARule, int& lastUARule);
243         void updateFont();
244         void cacheBorderAndBackground();
245
246         void mapFillAttachment(CSSPropertyID, FillLayer*, CSSValue*);
247         void mapFillClip(CSSPropertyID, FillLayer*, CSSValue*);
248         void mapFillComposite(CSSPropertyID, FillLayer*, CSSValue*);
249         void mapFillOrigin(CSSPropertyID, FillLayer*, CSSValue*);
250         void mapFillImage(CSSPropertyID, FillLayer*, CSSValue*);
251         void mapFillRepeatX(CSSPropertyID, FillLayer*, CSSValue*);
252         void mapFillRepeatY(CSSPropertyID, FillLayer*, CSSValue*);
253         void mapFillSize(CSSPropertyID, FillLayer*, CSSValue*);
254         void mapFillXPosition(CSSPropertyID, FillLayer*, CSSValue*);
255         void mapFillYPosition(CSSPropertyID, FillLayer*, CSSValue*);
256
257         void mapAnimationDelay(Animation*, CSSValue*);
258         void mapAnimationDirection(Animation*, CSSValue*);
259         void mapAnimationDuration(Animation*, CSSValue*);
260         void mapAnimationFillMode(Animation*, CSSValue*);
261         void mapAnimationIterationCount(Animation*, CSSValue*);
262         void mapAnimationName(Animation*, CSSValue*);
263         void mapAnimationPlayState(Animation*, CSSValue*);
264         void mapAnimationProperty(Animation*, CSSValue*);
265         void mapAnimationTimingFunction(Animation*, CSSValue*);
266
267         void mapNinePieceImage(CSSPropertyID, CSSValue*, NinePieceImage&);
268
269         void applyProperty(int id, CSSValue*);
270         void applyPageSizeProperty(CSSValue*);
271         bool pageSizeFromName(CSSPrimitiveValue*, CSSPrimitiveValue*, Length& width, Length& height);
272         Length mmLength(double mm);
273         Length inchLength(double inch);
274 #if ENABLE(SVG)
275         void applySVGProperty(int id, CSSValue*);
276 #endif
277
278         void loadPendingImages();
279         
280         StyleImage* styleImage(CSSPropertyID, CSSValue* value);
281         StyleImage* cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue* value);
282
283         // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
284         // set of matched decls four times, once for those properties that others depend on (like font-size),
285         // and then a second time for all the remaining properties.  We then do the same two passes
286         // for any !important rules.
287         Vector<CSSMutableStyleDeclaration*, 64> m_matchedDecls;
288
289         // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
290         // merge sorting.
291         Vector<CSSRuleData*, 32> m_matchedRules;
292
293         RefPtr<CSSRuleList> m_ruleList;
294         
295         HashSet<int> m_pendingImageProperties; // Hash of CSSPropertyIDs
296
297         OwnPtr<MediaQueryEvaluator> m_medium;
298         RefPtr<RenderStyle> m_rootDefaultStyle;
299
300         PseudoId m_dynamicPseudo;
301
302         SelectorChecker m_checker;
303
304         RefPtr<RenderStyle> m_style;
305         RenderStyle* m_parentStyle;
306         RenderStyle* m_rootElementStyle;
307         Element* m_element;
308         StyledElement* m_styledElement;
309         EInsideLink m_elementLinkState;
310         ContainerNode* m_parentNode;
311         CSSValue* m_lineHeightValue;
312         bool m_fontDirty;
313         bool m_matchAuthorAndUserStyles;
314         
315         RefPtr<CSSFontSelector> m_fontSelector;
316         HashSet<AtomicStringImpl*> m_selectorAttrs;
317         Vector<CSSMutableStyleDeclaration*> m_additionalAttributeStyleDecls;
318         Vector<MediaQueryResult*> m_viewportDependentMediaQueryResults;
319         
320         HashMap<String, CSSVariablesRule*> m_variablesMap;
321         HashMap<CSSMutableStyleDeclaration*, RefPtr<CSSMutableStyleDeclaration> > m_resolvedVariablesDeclarations;
322     };
323
324     class CSSRuleData : public Noncopyable {
325     public:
326         CSSRuleData(unsigned pos, CSSStyleRule* r, CSSSelector* sel, CSSRuleData* prev = 0)
327             : m_position(pos)
328             , m_rule(r)
329             , m_selector(sel)
330             , m_next(0)
331         {
332             if (prev)
333                 prev->m_next = this;
334         }
335
336         ~CSSRuleData() 
337         { 
338         }
339
340         unsigned position() { return m_position; }
341         CSSStyleRule* rule() { return m_rule; }
342         CSSSelector* selector() { return m_selector; }
343         CSSRuleData* next() { return m_next; }
344
345     private:
346         unsigned m_position;
347         CSSStyleRule* m_rule;
348         CSSSelector* m_selector;
349         CSSRuleData* m_next;
350     };
351
352     class CSSRuleDataList : public Noncopyable {
353     public:
354         CSSRuleDataList(unsigned pos, CSSStyleRule* rule, CSSSelector* sel)
355             : m_first(new CSSRuleData(pos, rule, sel))
356             , m_last(m_first)
357         {
358         }
359
360         ~CSSRuleDataList() 
361         { 
362             CSSRuleData* ptr;
363             CSSRuleData* next;
364             ptr = m_first;
365             while (ptr) {
366                 next = ptr->next();
367                 delete ptr;
368                 ptr = next;
369             }
370         }
371
372         CSSRuleData* first() { return m_first; }
373         CSSRuleData* last() { return m_last; }
374
375         void append(unsigned pos, CSSStyleRule* rule, CSSSelector* sel) { m_last = new CSSRuleData(pos, rule, sel, m_last); }
376
377     private:
378         CSSRuleData* m_first;
379         CSSRuleData* m_last;
380     };
381
382 } // namespace WebCore
383
384 #endif // CSSStyleSelector_h