WebCore:
[WebKit-https.git] / WebCore / css / CSSStyleSelector.h
1 /*
2  * This file is part of the CSS implementation for KDE.
3  *
4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
5  * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #ifndef CSSStyleSelector_h
25 #define CSSStyleSelector_h
26
27 #include "CSSFontSelector.h"
28 #include "DeprecatedString.h"
29 #include "RenderStyle.h"
30 #include <wtf/HashSet.h>
31 #include <wtf/Vector.h>
32 #include <wtf/RefPtr.h>
33
34 namespace WebCore {
35
36 class CSSMutableStyleDeclaration;
37 class CSSPrimitiveValue;
38 class CSSProperty;
39 class CSSFontFace;
40 class CSSFontFaceRule;
41 class CSSRuleData;
42 class CSSRuleDataList;
43 class CSSRuleList;
44 class CSSRuleSet;
45 class CSSSelector;
46 class CSSStyleRule;
47 class CSSStyleSheet;
48 class CSSValue;
49 class Document;
50 class Element;
51 class Frame;
52 class FrameView;
53 class KURL;
54 class MediaQueryEvaluator;
55 class Node;
56 class Settings;
57 class StyleSheet;
58 class StyleSheetList;
59 class StyledElement;
60
61     /**
62      * this class selects a RenderStyle for a given Element based on the
63      * collection of styleshets it contains. This is just a vrtual base class
64      * for specific implementations of the Selector. At the moment only CSSStyleSelector
65      * exists, but someone may wish to implement XSL.
66      */
67     class StyleSelector
68     {
69     public:
70         enum State {
71             None = 0x00,
72             Hover = 0x01,
73             Focus = 0x02,
74             Active = 0x04,
75             Drag = 0x08
76         };
77     };
78
79     /**
80      * the StyleSelector implementation for CSS.
81      */
82     class CSSStyleSelector : public StyleSelector
83     {
84     public:
85         CSSStyleSelector(Document*, const String& userStyleSheet, StyleSheetList *styleSheets, CSSStyleSheet* mappedElementsSheet, bool strictParsing, bool matchAuthorAndUserStyles);
86         ~CSSStyleSelector();
87
88         static void loadDefaultStyle();
89
90         void initElementAndPseudoState(Element* e);
91         void initForStyleResolve(Element* e, RenderStyle* parentStyle);
92         RenderStyle *styleForElement(Element*, RenderStyle* parentStyle=0, bool allowSharing=true, bool resolveForRootDefault=false);
93         RenderStyle* pseudoStyleForElement(RenderStyle::PseudoId, Element*, RenderStyle* parentStyle=0);
94
95         RenderStyle* locateSharedStyle();
96         Node* locateCousinList(Element* parent, unsigned depth = 1);
97         bool canShareStyleWithElement(Node* n);
98         
99         // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
100         RefPtr<CSSRuleList> styleRulesForElement(Element* e, bool authorOnly);
101         RefPtr<CSSRuleList> pseudoStyleRulesForElement(Element* e, StringImpl* pseudoStyle, bool authorOnly);
102
103         bool strictParsing;
104         
105         struct Encodedurl {
106             DeprecatedString host; //also contains protocol
107             DeprecatedString path;
108             DeprecatedString file;
109         } encodedurl;
110         void setEncodedURL(const KURL& url);
111         
112         // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
113         // the correct font size scaled relative to the user's default (medium).
114         float fontSizeForKeyword(int keyword, bool quirksMode, bool monospace) const;
115         
116         // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
117         // table, and failing that, will simply multiply by 1.2.
118         float largerFontSize(float size, bool quirksMode) const;
119         
120         // Like the previous function, but for the keyword "smaller".
121         float smallerFontSize(float size, bool quirksMode) const;
122         
123         void setFontSize(FontDescription& FontDescription, float size);
124         float getComputedSizeFromSpecifiedSize(bool isAbsoluteSize, float specifiedSize);
125         
126         Color getColorFromPrimitiveValue(CSSPrimitiveValue* primitiveValue);
127     
128         bool hasSelectorForAttribute(const AtomicString &attrname);
129  
130         CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
131
132     protected:
133
134         /* checks if a compound selector (which can consist of multiple simple selectors)
135            matches the given Element */
136         bool checkSelector(CSSSelector* selector);
137         enum SelectorMatch { SelectorMatches=0, SelectorFailsLocally, SelectorFailsCompletely};
138         SelectorMatch checkSelector(CSSSelector* selector, Element *e, bool isAncestor, bool isSubSelector);
139
140         /* checks if the selector matches the given Element */
141         bool checkOneSelector(CSSSelector*, Element*, bool isAncestor, bool isSubSelector = false);
142
143         /* This function fixes up the default font size if it detects that the
144            current generic font family has changed. -dwh */
145         void checkForGenericFamilyChange(RenderStyle* aStyle, RenderStyle* aParentStyle);
146         void checkForTextSizeAdjust();
147
148         void adjustRenderStyle(RenderStyle* style, Element *e);
149     
150         void addMatchedRule(CSSRuleData* rule) { m_matchedRules.append(rule); }
151         void addMatchedDeclaration(CSSMutableStyleDeclaration* decl) { m_matchedDecls.append(decl); }
152
153         void matchRules(CSSRuleSet* rules, int& firstRuleIndex, int& lastRuleIndex);
154         void matchRulesForList(CSSRuleDataList* rules, int& firstRuleIndex, int& lastRuleIndex);
155         void sortMatchedRules(unsigned start, unsigned end);
156
157         void applyDeclarations(bool firstPass, bool important, int startIndex, int endIndex);
158         
159         static CSSStyleSheet* defaultSheet;
160         static CSSStyleSheet* quirksSheet;
161         static CSSStyleSheet* viewSourceSheet;
162 #if ENABLE(SVG)
163         static CSSStyleSheet* svgSheet;
164 #endif
165
166         static CSSRuleSet* defaultStyle;
167         static CSSRuleSet* defaultQuirksStyle;
168         static CSSRuleSet* defaultPrintStyle;
169         static CSSRuleSet* defaultViewSourceStyle;
170
171         CSSRuleSet* m_authorStyle;
172         CSSRuleSet* m_userStyle;
173         RefPtr<CSSStyleSheet> m_userSheet;
174         
175         bool m_hasUAAppearance;
176         BorderData m_borderData;
177         BackgroundLayer m_backgroundData;
178         Color m_backgroundColor;
179
180     public:
181         static RenderStyle* styleNotYetAvailable;
182  
183     private:
184         void init();
185
186         void matchUARules(int& firstUARule, int& lastUARule);
187         void updateFont();
188         void cacheBorderAndBackground();
189          
190         void mapBackgroundAttachment(BackgroundLayer* layer, CSSValue* value);
191         void mapBackgroundClip(BackgroundLayer* layer, CSSValue* value);
192         void mapBackgroundComposite(BackgroundLayer* layer, CSSValue* value);
193         void mapBackgroundOrigin(BackgroundLayer* layer, CSSValue* value);
194         void mapBackgroundImage(BackgroundLayer* layer, CSSValue* value);
195         void mapBackgroundRepeat(BackgroundLayer* layer, CSSValue* value);
196         void mapBackgroundSize(BackgroundLayer* layer, CSSValue* value);
197         void mapBackgroundXPosition(BackgroundLayer* layer, CSSValue* value);
198         void mapBackgroundYPosition(BackgroundLayer* layer, CSSValue* value);
199         
200         void mapTransitionDuration(Transition*, CSSValue*);
201         void mapTransitionRepeatCount(Transition*, CSSValue*);
202         void mapTransitionTimingFunction(Transition*, CSSValue*);
203         void mapTransitionProperty(Transition*, CSSValue*);
204         
205         // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
206         // set of matched decls four times, once for those properties that others depend on (like font-size),
207         // and then a second time for all the remaining properties.  We then do the same two passes
208         // for any !important rules.
209         Vector<CSSMutableStyleDeclaration*> m_matchedDecls;
210         
211         // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
212         // merge sorting.
213         Vector<CSSRuleData*> m_matchedRules;
214         
215         CSSRuleList* m_ruleList;
216         bool m_collectRulesOnly;
217
218         MediaQueryEvaluator* m_medium;
219         RenderStyle* m_rootDefaultStyle;
220
221         RenderStyle::PseudoId dynamicPseudo;
222         
223         Document* m_document; // back pointer to owner document
224         RenderStyle *style;
225         RenderStyle *parentStyle;
226         Element *element;
227         StyledElement *styledElement;
228         Node *parentNode;
229         RenderStyle::PseudoId pseudoStyle;
230         CSSValue* m_lineHeightValue;
231         bool fontDirty;
232         bool isXMLDoc;
233         bool m_matchAuthorAndUserStyles;
234
235         RefPtr<CSSFontSelector> m_fontSelector;
236
237         HashSet<AtomicStringImpl*> m_selectorAttrs;
238         
239         void applyProperty(int id, CSSValue *value);
240 #if ENABLE(SVG)
241         void applySVGProperty(int id, CSSValue *value);
242 #endif
243
244         friend class CSSRuleSet;
245     };
246
247     class CSSRuleData {
248     public:
249         CSSRuleData(unsigned pos, CSSStyleRule* r, CSSSelector* sel, CSSRuleData* prev = 0)
250         :m_position(pos), m_rule(r), m_selector(sel), m_next(0) { if (prev) prev->m_next = this; }
251         ~CSSRuleData() { delete m_next; }
252
253         unsigned position() { return m_position; }
254         CSSStyleRule* rule() { return m_rule; }
255         CSSSelector* selector() { return m_selector; }
256         CSSRuleData* next() { return m_next; }
257         
258     private:
259         unsigned m_position;
260         CSSStyleRule* m_rule;
261         CSSSelector* m_selector;
262         CSSRuleData* m_next;
263     };
264
265     class CSSRuleDataList {
266     public:
267         CSSRuleDataList(unsigned pos, CSSStyleRule* rule, CSSSelector* sel)
268         { m_first = m_last = new CSSRuleData(pos, rule, sel); }
269         ~CSSRuleDataList() { delete m_first; }
270
271         CSSRuleData* first() { return m_first; }
272         CSSRuleData* last() { return m_last; }
273         
274         void append(unsigned pos, CSSStyleRule* rule, CSSSelector* sel) {
275             m_last = new CSSRuleData(pos, rule, sel, m_last);
276         }
277         
278     private:
279         CSSRuleData* m_first;
280         CSSRuleData* m_last;
281     };
282     
283 } // WebCore
284
285 #endif // CSSStyleSelector_h