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