Source/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 "CSSRule.h"
  27 #include "LinkHash.h"
  28 #include "MediaQueryExp.h"
  29 #include "RenderStyle.h"
  30 #include <wtf/HashMap.h>
  31 #include <wtf/HashSet.h>
  32 #include <wtf/RefPtr.h>
  33 #include <wtf/Vector.h>
  34 #include <wtf/text/StringHash.h>
  35
  36 namespace WebCore {
  37
  38 class CSSMutableStyleDeclaration;
  39 class CSSPageRule;
  40 class CSSPrimitiveValue;
  41 class CSSProperty;
  42 class CSSFontFace;
  43 class CSSFontFaceRule;
  44 class CSSImageValue;
  45 class CSSRuleList;
  46 class CSSSelector;
  47 class CSSStyleRule;
  48 class CSSStyleSheet;
  49 class CSSValue;
  50 class ContainerNode;
  51 class DataGridColumn;
  52 class Document;
  53 class Element;
  54 class Frame;
  55 class FrameView;
  56 class KURL;
  57 class KeyframeList;
  58 class KeyframeValue;
  59 class MediaQueryEvaluator;
  60 class Node;
  61 class RuleData;
  62 class RuleSet;
  63 class Settings;
  64 class StyleImage;
  65 class StyleSheet;
  66 class StyleSheetList;
  67 class StyledElement;
  68 class WebKitCSSKeyframeRule;
  69 class WebKitCSSKeyframesRule;
  70
  71 class MediaQueryResult {
  72     WTF_MAKE_NONCOPYABLE(MediaQueryResult); WTF_MAKE_FAST_ALLOCATED;
  73 public:
  74     MediaQueryResult(const MediaQueryExp& expr, bool result)
  75         : m_expression(expr)
  76         , m_result(result)
  77     {
  78     }
  79
  80     MediaQueryExp m_expression;
  81     bool m_result;
  82 };
  83
  84     // This class selects a RenderStyle for a given element based on a collection of stylesheets.
  85     class CSSStyleSelector {
  86         WTF_MAKE_NONCOPYABLE(CSSStyleSelector); WTF_MAKE_FAST_ALLOCATED;
  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         bool matchesSiblingRules();
 114         Node* locateCousinList(Element* parent, unsigned depth = 1) const;
 115         Node* findSiblingForStyleSharing(Node*, unsigned& count) const;
 116         bool canShareStyleWithElement(Node*) const;
 117
 118         RenderStyle* style() const { return m_style.get(); }
 119
 120         PassRefPtr<RenderStyle> styleForKeyframe(const RenderStyle*, const WebKitCSSKeyframeRule*, KeyframeValue&);
 121
 122     public:
 123         // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
 124         PassRefPtr<CSSRuleList> styleRulesForElement(Element*, bool authorOnly, bool includeEmptyRules = false, CSSRuleFilter filter = AllCSSRules);
 125         PassRefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, PseudoId, bool authorOnly, bool includeEmptyRules = false, CSSRuleFilter filter = AllCSSRules);
 126
 127         // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
 128         // the correct font size scaled relative to the user's default (medium).
 129         static float fontSizeForKeyword(Document*, int keyword, bool shouldUseFixedDefaultSize);
 130
 131         // Given a font size in pixel, this function will return legacy font size between 1 and 7.
 132         static int legacyFontSize(Document*, int pixelFontSize, bool shouldUseFixedDefaultSize);
 133
 134     private:
 135
 136         // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
 137         // table, and failing that, will simply multiply by 1.2.
 138         float largerFontSize(float size, bool quirksMode) const;
 139
 140         // Like the previous function, but for the keyword "smaller".
 141         float smallerFontSize(float size, bool quirksMode) const;
 142
 143     public:
 144         void setStyle(PassRefPtr<RenderStyle> s) { m_style = s; } // Used by the document when setting up its root style.
 145
 146         void applyPropertyToStyle(int id, CSSValue*, RenderStyle*);
 147
 148     private:
 149         void setFontSize(FontDescription&, float size);
 150         static float getComputedSizeFromSpecifiedSize(Document*, RenderStyle*, bool isAbsoluteSize, float specifiedSize, bool useSVGZoomRules);
 151
 152     public:
 153         Color getColorFromPrimitiveValue(CSSPrimitiveValue*) const;
 154
 155         bool hasSelectorForAttribute(const AtomicString&) const;
 156
 157         CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
 158
 159         // Checks if a compound selector (which can consist of multiple simple selectors) matches the current element.
 160         bool checkSelector(CSSSelector*);
 161
 162         void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
 163
 164         bool affectedByViewportChange() const;
 165
 166         void allVisitedStateChanged() { m_checker.allVisitedStateChanged(); }
 167         void visitedStateChanged(LinkHash visitedHash) { m_checker.visitedStateChanged(visitedHash); }
 168
 169         void addKeyframeStyle(PassRefPtr<WebKitCSSKeyframesRule> rule);
 170         void addPageStyle(PassRefPtr<CSSPageRule>);
 171
 172         static bool createTransformOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, TransformOperations& outOperations);
 173
 174     private:
 175         enum SelectorMatch { SelectorMatches, SelectorFailsLocally, SelectorFailsCompletely };
 176
 177         // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
 178         void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
 179         void checkForZoomChange(RenderStyle*, RenderStyle* parentStyle);
 180         void checkForTextSizeAdjust();
 181
 182         void adjustRenderStyle(RenderStyle* styleToAdjust, RenderStyle* parentStyle, Element*);
 183
 184         void addMatchedRule(const RuleData* rule) { m_matchedRules.append(rule); }
 185         void addMatchedDeclaration(CSSMutableStyleDeclaration* decl);
 186
 187         void matchRules(RuleSet*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);
 188         void matchRulesForList(const Vector<RuleData>*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);
 189         void sortMatchedRules(unsigned start, unsigned end);
 190
 191         template <bool firstPass>
 192         void applyDeclarations(bool important, int startIndex, int endIndex);
 193
 194         void matchPageRules(RuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
 195         void matchPageRulesForList(const Vector<RuleData>*, bool isLeftPage, bool isFirstPage, const String& pageName);
 196         bool isLeftPage(int pageIndex) const;
 197         bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
 198         bool isFirstPage(int pageIndex) const;
 199         String pageName(int pageIndex) const;
 200
 201         OwnPtr<RuleSet> m_authorStyle;
 202         OwnPtr<RuleSet> m_userStyle;
 203
 204         OwnPtr<RuleSet> m_siblingRules;
 205         HashSet<AtomicStringImpl*> m_idsInRules;
 206
 207         bool m_hasUAAppearance;
 208         BorderData m_borderData;
 209         FillLayer m_backgroundData;
 210         Color m_backgroundColor;
 211
 212         typedef HashMap<AtomicStringImpl*, RefPtr<WebKitCSSKeyframesRule> > KeyframesRuleMap;
 213         KeyframesRuleMap m_keyframesRuleMap;
 214
 215     public:
 216         static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
 217
 218         class SelectorChecker {
 219             WTF_MAKE_NONCOPYABLE(SelectorChecker);
 220         public:
 221             SelectorChecker(Document*, bool strictParsing);
 222
 223             bool checkSelector(CSSSelector*, Element*) const;
 224             SelectorMatch checkSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, bool encounteredLink, RenderStyle* = 0, RenderStyle* elementParentStyle = 0) const;
 225             bool checkOneSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, RenderStyle*, RenderStyle* elementParentStyle) const;
 226             bool checkScrollbarPseudoClass(CSSSelector*, PseudoId& dynamicPseudo) const;
 227
 228             EInsideLink determineLinkState(Element* element) const;
 229             EInsideLink determineLinkStateSlowCase(Element* element) const;
 230             void allVisitedStateChanged();
 231             void visitedStateChanged(LinkHash visitedHash);
 232
 233             Document* m_document;
 234             bool m_strictParsing;
 235             bool m_collectRulesOnly;
 236             bool m_sameOriginOnly;
 237             PseudoId m_pseudoStyle;
 238             bool m_documentIsHTML;
 239             mutable bool m_matchVisitedPseudoClass;
 240             mutable HashSet<LinkHash, LinkHashHash> m_linksCheckedForVisitedState;
 241         };
 242
 243     private:
 244         static RenderStyle* s_styleNotYetAvailable;
 245
 246         void matchUARules(int& firstUARule, int& lastUARule);
 247         void updateFont();
 248         void cacheBorderAndBackground();
 249
 250         void mapFillAttachment(CSSPropertyID, FillLayer*, CSSValue*);
 251         void mapFillClip(CSSPropertyID, FillLayer*, CSSValue*);
 252         void mapFillComposite(CSSPropertyID, FillLayer*, CSSValue*);
 253         void mapFillOrigin(CSSPropertyID, FillLayer*, CSSValue*);
 254         void mapFillImage(CSSPropertyID, FillLayer*, CSSValue*);
 255         void mapFillRepeatX(CSSPropertyID, FillLayer*, CSSValue*);
 256         void mapFillRepeatY(CSSPropertyID, FillLayer*, CSSValue*);
 257         void mapFillSize(CSSPropertyID, FillLayer*, CSSValue*);
 258         void mapFillXPosition(CSSPropertyID, FillLayer*, CSSValue*);
 259         void mapFillYPosition(CSSPropertyID, FillLayer*, CSSValue*);
 260
 261         void mapAnimationDelay(Animation*, CSSValue*);
 262         void mapAnimationDirection(Animation*, CSSValue*);
 263         void mapAnimationDuration(Animation*, CSSValue*);
 264         void mapAnimationFillMode(Animation*, CSSValue*);
 265         void mapAnimationIterationCount(Animation*, CSSValue*);
 266         void mapAnimationName(Animation*, CSSValue*);
 267         void mapAnimationPlayState(Animation*, CSSValue*);
 268         void mapAnimationProperty(Animation*, CSSValue*);
 269         void mapAnimationTimingFunction(Animation*, CSSValue*);
 270
 271         void mapNinePieceImage(CSSPropertyID, CSSValue*, NinePieceImage&);
 272
 273         void applyProperty(int id, CSSValue*);
 274         void applyPageSizeProperty(CSSValue*);
 275         bool pageSizeFromName(CSSPrimitiveValue*, CSSPrimitiveValue*, Length& width, Length& height);
 276         Length mmLength(double mm) const;
 277         Length inchLength(double inch) const;
 278 #if ENABLE(SVG)
 279         void applySVGProperty(int id, CSSValue*);
 280 #endif
 281
 282         void loadPendingImages();
 283
 284         StyleImage* styleImage(CSSPropertyID, CSSValue* value);
 285         StyleImage* cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue* value);
 286
 287         // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
 288         // set of matched decls four times, once for those properties that others depend on (like font-size),
 289         // and then a second time for all the remaining properties.  We then do the same two passes
 290         // for any !important rules.
 291         Vector<CSSMutableStyleDeclaration*, 64> m_matchedDecls;
 292
 293         // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
 294         // merge sorting.
 295         Vector<const RuleData*, 32> m_matchedRules;
 296
 297         RefPtr<CSSRuleList> m_ruleList;
 298
 299         HashSet<int> m_pendingImageProperties; // Hash of CSSPropertyIDs
 300
 301         OwnPtr<MediaQueryEvaluator> m_medium;
 302         RefPtr<RenderStyle> m_rootDefaultStyle;
 303
 304         PseudoId m_dynamicPseudo;
 305
 306         SelectorChecker m_checker;
 307
 308         RefPtr<RenderStyle> m_style;
 309         RenderStyle* m_parentStyle;
 310         RenderStyle* m_rootElementStyle;
 311         Element* m_element;
 312         StyledElement* m_styledElement;
 313         EInsideLink m_elementLinkState;
 314         ContainerNode* m_parentNode;
 315         CSSValue* m_lineHeightValue;
 316         bool m_fontDirty;
 317         bool m_matchAuthorAndUserStyles;
 318
 319         RefPtr<CSSFontSelector> m_fontSelector;
 320         HashSet<AtomicStringImpl*> m_selectorAttrs;
 321         Vector<CSSMutableStyleDeclaration*> m_additionalAttributeStyleDecls;
 322         Vector<MediaQueryResult*> m_viewportDependentMediaQueryResults;
 323     };
 324
 325 } // namespace WebCore
 326
 327 #endif // CSSStyleSelector_h