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