Rubber-stamped by Sam Weinig.
[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     public:
69         enum State {
70             None = 0x00,
71             Hover = 0x01,
72             Focus = 0x02,
73             Active = 0x04,
74             Drag = 0x08
75         };
76     };
77
78     /**
79      * the StyleSelector implementation for CSS.
80      */
81     class CSSStyleSelector : public StyleSelector {
82     public:
83         CSSStyleSelector(Document*, const String& userStyleSheet, StyleSheetList*, CSSStyleSheet*, bool strictParsing, bool matchAuthorAndUserStyles);
84         ~CSSStyleSelector();
85
86         static void loadDefaultStyle();
87
88         void initElementAndPseudoState(Element*);
89         void initForStyleResolve(Element*, RenderStyle* parentStyle);
90         RenderStyle* styleForElement(Element*, RenderStyle* parentStyle = 0, bool allowSharing = true, bool resolveForRootDefault = false);
91         RenderStyle* pseudoStyleForElement(RenderStyle::PseudoId, Element*, RenderStyle* parentStyle = 0);
92
93         RenderStyle* locateSharedStyle();
94         Node* locateCousinList(Element* parent, unsigned depth = 1);
95         bool canShareStyleWithElement(Node* n);
96
97         // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
98         RefPtr<CSSRuleList> styleRulesForElement(Element*, bool authorOnly);
99         RefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, StringImpl* pseudoStyle, bool authorOnly);
100
101         bool strictParsing;
102
103         struct Encodedurl {
104             DeprecatedString host; //also contains protocol
105             DeprecatedString path;
106             DeprecatedString file;
107         } m_encodedURL;
108
109         void setEncodedURL(const KURL& url);
110
111         // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
112         // the correct font size scaled relative to the user's default (medium).
113         float fontSizeForKeyword(int keyword, bool quirksMode, bool monospace) const;
114
115         // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
116         // table, and failing that, will simply multiply by 1.2.
117         float largerFontSize(float size, bool quirksMode) const;
118
119         // Like the previous function, but for the keyword "smaller".
120         float smallerFontSize(float size, bool quirksMode) const;
121
122         void setFontSize(FontDescription&, float size);
123         float getComputedSizeFromSpecifiedSize(bool isAbsoluteSize, float specifiedSize);
124
125         Color getColorFromPrimitiveValue(CSSPrimitiveValue*);
126
127         bool hasSelectorForAttribute(const AtomicString&);
128  
129         CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
130
131         /* checks if a compound selector (which can consist of multiple simple selectors)
132            matches the given Element */
133         bool checkSelector(CSSSelector*);
134
135     protected:
136         enum SelectorMatch {
137             SelectorMatches = 0,
138             SelectorFailsLocally,
139             SelectorFailsCompletely
140         };
141
142         SelectorMatch checkSelector(CSSSelector*, Element *, bool isAncestor, bool isSubSelector);
143
144         /* checks if the selector matches the given Element */
145         bool checkOneSelector(CSSSelector*, Element*, bool isAncestor, bool isSubSelector = false);
146
147         /* This function fixes up the default font size if it detects that the
148            current generic font family has changed. -dwh */
149         void checkForGenericFamilyChange(RenderStyle* style, RenderStyle* parentStyle);
150         void checkForTextSizeAdjust();
151
152         void adjustRenderStyle(RenderStyle*, Element*);
153
154         void addMatchedRule(CSSRuleData* rule) { m_matchedRules.append(rule); }
155         void addMatchedDeclaration(CSSMutableStyleDeclaration* decl) { m_matchedDecls.append(decl); }
156
157         void matchRules(CSSRuleSet*, int& firstRuleIndex, int& lastRuleIndex);
158         void matchRulesForList(CSSRuleDataList* rules, int& firstRuleIndex, int& lastRuleIndex);
159         void sortMatchedRules(unsigned start, unsigned end);
160
161         void applyDeclarations(bool firstPass, bool important, int startIndex, int endIndex);
162
163         static CSSStyleSheet* m_defaultSheet;
164         static CSSStyleSheet* m_quirksSheet;
165         static CSSStyleSheet* m_viewSourceSheet;
166 #if ENABLE(SVG)
167         static CSSStyleSheet* m_svgSheet;
168 #endif
169
170         static CSSRuleSet* m_defaultStyle;
171         static CSSRuleSet* m_defaultQuirksStyle;
172         static CSSRuleSet* m_defaultPrintStyle;
173         static CSSRuleSet* m_defaultViewSourceStyle;
174
175         CSSRuleSet* m_authorStyle;
176         CSSRuleSet* m_userStyle;
177         RefPtr<CSSStyleSheet> m_userSheet;
178
179         bool m_hasUAAppearance;
180         BorderData m_borderData;
181         BackgroundLayer m_backgroundData;
182         Color m_backgroundColor;
183
184     public:
185         static RenderStyle* m_styleNotYetAvailable;
186
187     private:
188         void init();
189
190         void matchUARules(int& firstUARule, int& lastUARule);
191         void updateFont();
192         void cacheBorderAndBackground();
193
194         void mapBackgroundAttachment(BackgroundLayer*, CSSValue*);
195         void mapBackgroundClip(BackgroundLayer*, CSSValue*);
196         void mapBackgroundComposite(BackgroundLayer*, CSSValue*);
197         void mapBackgroundOrigin(BackgroundLayer*, CSSValue*);
198         void mapBackgroundImage(BackgroundLayer*, CSSValue*);
199         void mapBackgroundRepeat(BackgroundLayer*, CSSValue*);
200         void mapBackgroundSize(BackgroundLayer*, CSSValue*);
201         void mapBackgroundXPosition(BackgroundLayer*, CSSValue*);
202         void mapBackgroundYPosition(BackgroundLayer*, CSSValue*);
203
204         void mapTransitionDuration(Transition*, CSSValue*);
205         void mapTransitionRepeatCount(Transition*, CSSValue*);
206         void mapTransitionTimingFunction(Transition*, CSSValue*);
207         void mapTransitionProperty(Transition*, CSSValue*);
208
209         // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
210         // set of matched decls four times, once for those properties that others depend on (like font-size),
211         // and then a second time for all the remaining properties.  We then do the same two passes
212         // for any !important rules.
213         Vector<CSSMutableStyleDeclaration*> m_matchedDecls;
214
215         // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
216         // merge sorting.
217         Vector<CSSRuleData*> m_matchedRules;
218
219         CSSRuleList* m_ruleList;
220         bool m_collectRulesOnly;
221
222         MediaQueryEvaluator* m_medium;
223         RenderStyle* m_rootDefaultStyle;
224
225         RenderStyle::PseudoId dynamicPseudo;
226
227         Document* m_document; // back pointer to owner document
228         RenderStyle* m_style;
229         RenderStyle* m_parentStyle;
230         Element* m_element;
231         StyledElement* m_styledElement;
232         Node* m_parentNode;
233         RenderStyle::PseudoId m_pseudoStyle;
234         CSSValue* m_lineHeightValue;
235         bool m_fontDirty;
236         bool m_isXMLDoc;
237         bool m_matchAuthorAndUserStyles;
238
239         RefPtr<CSSFontSelector> m_fontSelector;
240
241         HashSet<AtomicStringImpl*> m_selectorAttrs;
242
243         void applyProperty(int id, CSSValue*);
244 #if ENABLE(SVG)
245         void applySVGProperty(int id, CSSValue*);
246 #endif
247
248         friend class CSSRuleSet;
249         friend class Node;
250     };
251
252     class CSSRuleData {
253     public:
254         CSSRuleData(unsigned pos, CSSStyleRule* r, CSSSelector* sel, CSSRuleData* prev = 0)
255             : m_position(pos)
256             , m_rule(r)
257             , m_selector(sel)
258             , m_next(0)
259         {
260             if (prev)
261                 prev->m_next = this;
262         }
263
264         ~CSSRuleData() { delete m_next; }
265
266         unsigned position() { return m_position; }
267         CSSStyleRule* rule() { return m_rule; }
268         CSSSelector* selector() { return m_selector; }
269         CSSRuleData* next() { return m_next; }
270
271     private:
272         unsigned m_position;
273         CSSStyleRule* m_rule;
274         CSSSelector* m_selector;
275         CSSRuleData* m_next;
276     };
277
278     class CSSRuleDataList {
279     public:
280         CSSRuleDataList(unsigned pos, CSSStyleRule* rule, CSSSelector* sel)
281             : m_first(new CSSRuleData(pos, rule, sel))
282             , m_last(m_first)
283         {
284         }
285
286         ~CSSRuleDataList() { delete m_first; }
287
288         CSSRuleData* first() { return m_first; }
289         CSSRuleData* last() { return m_last; }
290
291         void append(unsigned pos, CSSStyleRule* rule, CSSSelector* sel) { m_last = new CSSRuleData(pos, rule, sel, m_last); }
292
293     private:
294         CSSRuleData* m_first;
295         CSSRuleData* m_last;
296     };
297     
298 } // namespace WebCore
299
300 #endif // CSSStyleSelector_h