Fix for 3558334.
[WebKit-https.git] / WebCore / khtml / 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 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., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  *
22  */
23 #ifndef _CSS_cssstyleselector_h_
24 #define _CSS_cssstyleselector_h_
25
26 #include <qptrvector.h>
27 #include <qptrdict.h>
28
29 #include "rendering/render_style.h"
30 #include "dom/dom_string.h"
31 #include "css/css_ruleimpl.h"
32
33 class KHTMLSettings;
34 class KHTMLView;
35 class KHTMLPart;
36 class KURL;
37
38 namespace DOM {
39     class DocumentImpl;
40     class NodeImpl;
41     class ElementImpl;
42     class HTMLElementImpl;
43     class StyleSheetImpl;
44     class CSSStyleSheetImpl;
45     class CSSSelector;
46     class CSSProperty;
47     class StyleSheetListImpl;
48     class CSSValueImpl;
49 }
50
51 namespace khtml
52 {
53     class CSSRuleData;
54     class CSSRuleDataList;
55     class CSSRuleSet;
56     class RenderStyle;
57
58     /**
59      * this class selects a RenderStyle for a given Element based on the
60      * collection of styleshets it contains. This is just a vrtual base class
61      * for specific implementations of the Selector. At the moment only CSSStyleSelector
62      * exists, but someone may wish to implement XSL...
63      */
64     class StyleSelector
65     {
66     public:
67         StyleSelector() {};
68
69         /* as noone has implemented a second style selector up to now comment out
70            the virtual methods until then, so the class has no vptr.
71         */
72 //      virtual ~StyleSelector() {};
73 //      virtual RenderStyle *styleForElement(DOM::ElementImpl *e) = 0;
74
75         enum State {
76             None = 0x00,
77             Hover = 0x01,
78             Focus = 0x02,
79             Active = 0x04,
80             Drag = 0x08
81         };
82     };
83
84
85     /**
86      * the StyleSelector implementation for CSS.
87      */
88     class CSSStyleSelector : public StyleSelector
89     {
90     public:
91         /**
92          * creates a new StyleSelector for a Document.
93          * goes through all StyleSheets defined in the document and
94          * creates a list of rules it needs to apply to objects
95          */
96         CSSStyleSelector(DOM::DocumentImpl* doc, QString userStyleSheet, 
97                          DOM::StyleSheetListImpl *styleSheets,
98                          bool _strictParsing);
99         /**
100          * same as above but for a single stylesheet.
101          */
102         CSSStyleSelector(DOM::CSSStyleSheetImpl *sheet);
103         ~CSSStyleSelector();
104
105         static void loadDefaultStyle(const KHTMLSettings *s = 0);
106
107         void initElementAndPseudoState(DOM::ElementImpl* e);
108         void initForStyleResolve(DOM::ElementImpl* e, RenderStyle* parentStyle);
109         RenderStyle *styleForElement(DOM::ElementImpl* e, RenderStyle* parentStyle=0, bool allowSharing=true);
110         RenderStyle* pseudoStyleForElement(RenderStyle::PseudoId pseudoStyle, 
111                                            DOM::ElementImpl* e, RenderStyle* parentStyle=0);
112
113         RenderStyle* locateSharedStyle();
114         DOM::NodeImpl* locateCousinList(DOM::ElementImpl* parent);
115         bool canShareStyleWithElement(DOM::NodeImpl* e);
116         
117         bool strictParsing;
118         
119         struct Encodedurl {
120             QString host; //also contains protocol
121             QString path;
122             QString file;
123         } encodedurl;
124         void setEncodedURL(const KURL& url);
125         
126         // Given a CSS keyword in the range (xx-small to -khtml-xxx-large), this function will return
127         // the correct font size scaled relative to the user's default (medium).
128         float fontSizeForKeyword(int keyword, bool quirksMode) const;
129         
130         // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
131         // table, and failing that, will simply multiply by 1.2.
132         float largerFontSize(float size, bool quirksMode) const;
133         
134         // Like the previous function, but for the keyword "smaller".
135         float smallerFontSize(float size, bool quirksMode) const;
136         
137         void setFontSize(FontDef& fontDef, float size);
138         float getComputedSizeFromSpecifiedSize(bool isAbsoluteSize, float specifiedSize);
139         
140         QColor getColorFromPrimitiveValue(DOM::CSSPrimitiveValueImpl* primitiveValue);
141         
142     protected:
143
144         /* checks if a compound selector (which can consist of multiple simple selectors)
145            matches the given Element */
146         bool checkSelector(DOM::CSSSelector* selector, DOM::ElementImpl *e);
147         
148         /* checks if the selector matches the given Element */
149         bool checkOneSelector(DOM::CSSSelector *selector, DOM::ElementImpl *e);
150
151         /* This function fixes up the default font size if it detects that the
152            current generic font family has changed. -dwh */
153         void checkForGenericFamilyChange(RenderStyle* aStyle, RenderStyle* aParentStyle);
154 #if APPLE_CHANGES
155         void checkForTextSizeAdjust();
156 #endif
157
158         void adjustRenderStyle(RenderStyle* style, DOM::ElementImpl *e);
159     
160         void matchRules(CSSRuleSet* rules, int& firstRuleIndex, int& lastRuleIndex);
161         void matchRulesForList(CSSRuleDataList* rules,
162                                int& firstRuleIndex, int& lastRuleIndex);
163         void sortMatchedRules(uint firstRuleIndex, uint lastRuleIndex);
164         void addMatchedRule(CSSRuleData* rule);
165         void addMatchedDeclaration(DOM::CSSStyleDeclarationImpl* decl);
166         void applyDeclarations(bool firstPass, bool important, int startIndex, int endIndex);
167         
168         static DOM::CSSStyleSheetImpl *defaultSheet;
169         static DOM::CSSStyleSheetImpl *quirksSheet;
170         static CSSRuleSet* defaultStyle;
171         static CSSRuleSet* defaultQuirksStyle;
172         static CSSRuleSet* defaultPrintStyle;
173         CSSRuleSet* m_authorStyle;
174         CSSRuleSet* m_userStyle;
175         DOM::CSSStyleSheetImpl* m_userSheet;
176
177 public:
178         static RenderStyle* styleNotYetAvailable;
179  
180     private:
181         void init();
182
183     protected:
184         // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
185         // set of matched decls four times, once for those properties that others depend on (like font-size),
186         // and then a second time for all the remaining properties.  We then do the same two passes
187         // for any !important rules.
188         QMemArray<DOM::CSSStyleDeclarationImpl*> m_matchedDecls;
189         unsigned m_matchedDeclCount;
190         
191         // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
192         // merge sorting.
193         QMemArray<CSSRuleData*> m_matchedRules;
194         unsigned m_matchedRuleCount;
195         QMemArray<CSSRuleData*> m_tmpRules;
196         unsigned m_tmpRuleCount;
197         
198         QString m_medium;
199
200         RenderStyle::PseudoId dynamicPseudo;
201         
202         RenderStyle *style;
203         RenderStyle *parentStyle;
204         DOM::ElementImpl *element;
205         DOM::HTMLElementImpl *htmlElement;
206         DOM::NodeImpl *parentNode;
207         RenderStyle::PseudoId pseudoStyle;
208         KHTMLView *view;
209         KHTMLPart *part;
210         const KHTMLSettings *settings;
211         QPaintDeviceMetrics *paintDeviceMetrics;
212         bool fontDirty;
213         bool isXMLDoc;
214         
215         void applyProperty(int id, DOM::CSSValueImpl *value);
216     };
217
218     class CSSRuleData {
219     public:
220         CSSRuleData(uint pos, DOM::CSSStyleRuleImpl* r, DOM::CSSSelector* sel, CSSRuleData* prev = 0)
221         :m_position(pos), m_rule(r), m_selector(sel), m_next(0) { if (prev) prev->m_next = this; }
222         ~CSSRuleData() { delete m_next; }
223
224         uint position() { return m_position; }
225         DOM::CSSStyleRuleImpl* rule() { return m_rule; }
226         DOM::CSSSelector* selector() { return m_selector; }
227         CSSRuleData* next() { return m_next; }
228         
229     private:
230         uint m_position;
231         DOM::CSSStyleRuleImpl* m_rule;
232         DOM::CSSSelector* m_selector;
233         CSSRuleData* m_next;
234     };
235
236     class CSSRuleDataList {
237     public:
238         CSSRuleDataList(uint pos, DOM::CSSStyleRuleImpl* rule, DOM::CSSSelector* sel)
239         { m_first = m_last = new CSSRuleData(pos, rule, sel); }
240         ~CSSRuleDataList() { delete m_first; }
241
242         CSSRuleData* first() { return m_first; }
243         CSSRuleData* last() { return m_last; }
244         
245         void append(uint pos, DOM::CSSStyleRuleImpl* rule, DOM::CSSSelector* sel) {
246             m_last = new CSSRuleData(pos, rule, sel, m_last);
247         }
248         
249     private:
250         CSSRuleData* m_first;
251         CSSRuleData* m_last;
252     };
253     
254     class CSSRuleSet
255     {
256     public:
257         CSSRuleSet();
258         ~CSSRuleSet() { delete m_universalRules; }
259
260         void addRulesFromSheet(DOM::CSSStyleSheetImpl* sheet, const DOM::DOMString &medium = "screen");
261
262         void addRule(DOM::CSSStyleRuleImpl* rule, DOM::CSSSelector* sel);
263         void addToRuleSet(void* hash, QPtrDict<CSSRuleDataList>& dict,
264                           DOM::CSSStyleRuleImpl* rule, DOM::CSSSelector* sel);
265
266         CSSRuleDataList* getIDRules(void* hash) { return m_idRules.find(hash); }
267         CSSRuleDataList* getClassRules(void* hash) { return m_classRules.find(hash); }
268         CSSRuleDataList* getTagRules(void* hash) { return m_tagRules.find(hash); }
269         CSSRuleDataList* getUniversalRules() { return m_universalRules; }
270
271     public:
272         QPtrDict<CSSRuleDataList> m_idRules;
273         QPtrDict<CSSRuleDataList> m_classRules;
274         QPtrDict<CSSRuleDataList> m_tagRules;
275         CSSRuleDataList*          m_universalRules;
276         
277         uint m_ruleCount;
278     };
279 };
280 #endif