src/third_party/WebKit/Source/core/css/resolver/StyleResolverState.h

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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 StyleResolverState_h
  23 #define StyleResolverState_h
  24
  25 #include "CSSPropertyNames.h"
  26
  27 #include "core/css/CSSSVGDocumentValue.h"
  28 #include "core/css/CSSToLengthConversionData.h"
  29 #include "core/css/resolver/CSSToStyleMap.h"
  30 #include "core/css/resolver/ElementResolveContext.h"
  31 #include "core/css/resolver/ElementStyleResources.h"
  32 #include "core/css/resolver/FontBuilder.h"
  33 #include "core/dom/Element.h"
  34 #include "core/rendering/style/CachedUAStyle.h"
  35 #include "core/rendering/style/RenderStyle.h"
  36 #include "core/rendering/style/StyleInheritedData.h"
  37
  38 namespace WebCore {
  39
  40 class CSSAnimationUpdate;
  41 class FontDescription;
  42 class StyleRule;
  43
  44 class StyleResolverState {
  45 WTF_MAKE_NONCOPYABLE(StyleResolverState);
  46 public:
  47     StyleResolverState(Document&, Element*, RenderStyle* parentStyle = 0);
  48     ~StyleResolverState();
  49
  50     // In FontFaceSet and CanvasRenderingContext2D, we don't have an element to grab the document from.
  51     // This is why we have to store the document separately.
  52     Document& document() const { return m_document; }
  53     // These are all just pass-through methods to ElementResolveContext.
  54     Element* element() const { return m_elementContext.element(); }
  55     const ContainerNode* parentNode() const { return m_elementContext.parentNode(); }
  56     const RenderStyle* rootElementStyle() const { return m_elementContext.rootElementStyle(); }
  57     EInsideLink elementLinkState() const { return m_elementContext.elementLinkState(); }
  58     bool distributedToInsertionPoint() const { return m_elementContext.distributedToInsertionPoint(); }
  59
  60     const ElementResolveContext& elementContext() const { return m_elementContext; }
  61
  62     void setStyle(PassRefPtr<RenderStyle> style) { m_style = style; m_cssToLengthConversionData.setStyle(m_style.get()); }
  63     const RenderStyle* style() const { return m_style.get(); }
  64     RenderStyle* style() { return m_style.get(); }
  65     PassRefPtr<RenderStyle> takeStyle() { return m_style.release(); }
  66
  67     const CSSToLengthConversionData& cssToLengthConversionData() const { return m_cssToLengthConversionData; }
  68
  69     void setAnimationUpdate(PassOwnPtr<CSSAnimationUpdate>);
  70     const CSSAnimationUpdate* animationUpdate() { return m_animationUpdate.get(); }
  71     PassOwnPtr<CSSAnimationUpdate> takeAnimationUpdate();
  72
  73     void setParentStyle(PassRefPtr<RenderStyle> parentStyle) { m_parentStyle = parentStyle; }
  74     const RenderStyle* parentStyle() const { return m_parentStyle.get(); }
  75     RenderStyle* parentStyle() { return m_parentStyle.get(); }
  76
  77     void setCurrentRule(StyleRule* currentRule) { m_currentRule = currentRule; }
  78     const StyleRule* currentRule() const { return m_currentRule; }
  79
  80     // FIXME: These are effectively side-channel "out parameters" for the various
  81     // map functions. When we map from CSS to style objects we use this state object
  82     // to track various meta-data about that mapping (e.g. if it's cache-able).
  83     // We need to move this data off of StyleResolverState and closer to the
  84     // objects it applies to. Possibly separating (immutable) inputs from (mutable) outputs.
  85     void setApplyPropertyToRegularStyle(bool isApply) { m_applyPropertyToRegularStyle = isApply; }
  86     void setApplyPropertyToVisitedLinkStyle(bool isApply) { m_applyPropertyToVisitedLinkStyle = isApply; }
  87     bool applyPropertyToRegularStyle() const { return m_applyPropertyToRegularStyle; }
  88     bool applyPropertyToVisitedLinkStyle() const { return m_applyPropertyToVisitedLinkStyle; }
  89
  90     // Holds all attribute names found while applying "content" properties that contain an "attr()" value.
  91     Vector<AtomicString>& contentAttrValues() { return m_contentAttrValues; }
  92
  93     void setLineHeightValue(CSSValue* value) { m_lineHeightValue = value; }
  94     CSSValue* lineHeightValue() { return m_lineHeightValue; }
  95
  96     void cacheUserAgentBorderAndBackground() { m_cachedUAStyle = CachedUAStyle(style()); }
  97     const CachedUAStyle& cachedUAStyle() const { return m_cachedUAStyle; }
  98
  99     ElementStyleResources& elementStyleResources() { return m_elementStyleResources; }
 100     const CSSToStyleMap& styleMap() const { return m_styleMap; }
 101     CSSToStyleMap& styleMap() { return m_styleMap; }
 102
 103     // FIXME: Once styleImage can be made to not take a StyleResolverState
 104     // this convenience function should be removed. As-is, without this, call
 105     // sites are extremely verbose.
 106     PassRefPtr<StyleImage> styleImage(CSSPropertyID propertyId, CSSValue* value)
 107     {
 108         return m_elementStyleResources.styleImage(document().textLinkColors(), style()->color(), propertyId, value);
 109     }
 110
 111     FontBuilder& fontBuilder() { return m_fontBuilder; }
 112     // FIXME: These exist as a primitive way to track mutations to font-related properties
 113     // on a RenderStyle. As designed, these are very error-prone, as some callers
 114     // set these directly on the RenderStyle w/o telling us. Presumably we'll
 115     // want to design a better wrapper around RenderStyle for tracking these mutations
 116     // and separate it from StyleResolverState.
 117     const FontDescription& parentFontDescription() { return m_parentStyle->fontDescription(); }
 118     void setZoom(float f) { m_fontBuilder.didChangeFontParameters(m_style->setZoom(f)); }
 119     void setEffectiveZoom(float f) { m_fontBuilder.didChangeFontParameters(m_style->setEffectiveZoom(f)); }
 120     void setWritingMode(WritingMode writingMode) { m_fontBuilder.didChangeFontParameters(m_style->setWritingMode(writingMode)); }
 121     void setTextOrientation(TextOrientation textOrientation) { m_fontBuilder.didChangeFontParameters(m_style->setTextOrientation(textOrientation)); }
 122
 123     // SVG handles zooming in a different way compared to CSS. The whole document is scaled instead
 124     // of each individual length value in the render style / tree. CSSPrimitiveValue::computeLength*()
 125     // multiplies each resolved length with the zoom multiplier - so for SVG we need to disable that.
 126     // Though all CSS values that can be applied to outermost <svg> elements (width/height/border/padding...)
 127     // need to respect the scaling. RenderBox (the parent class of RenderSVGRoot) grabs values like
 128     // width/height/border/padding/... from the RenderStyle -> for SVG these values would never scale,
 129     // if we'd pass a 1.0 zoom factor everyhwere. So we only pass a zoom factor of 1.0 for specific
 130     // properties that are NOT allowed to scale within a zoomed SVG document (letter/word-spacing/font-size).
 131     bool useSVGZoomRules() const { return element() && element()->isSVGElement(); }
 132
 133 private:
 134     friend class StyleResolveScope;
 135
 136     ElementResolveContext m_elementContext;
 137     Document& m_document;
 138
 139     // m_style is the primary output for each element's style resolve.
 140     RefPtr<RenderStyle> m_style;
 141
 142     CSSToLengthConversionData m_cssToLengthConversionData;
 143
 144     // m_parentStyle is not always just element->parentNode()->style()
 145     // so we keep it separate from m_elementContext.
 146     RefPtr<RenderStyle> m_parentStyle;
 147
 148     OwnPtr<CSSAnimationUpdate> m_animationUpdate;
 149
 150     bool m_applyPropertyToRegularStyle;
 151     bool m_applyPropertyToVisitedLinkStyle;
 152
 153     CSSValue* m_lineHeightValue;
 154
 155     FontBuilder m_fontBuilder;
 156
 157     CachedUAStyle m_cachedUAStyle;
 158
 159     ElementStyleResources m_elementStyleResources;
 160     // CSSToStyleMap is a pure-logic class and only contains
 161     // a back-pointer to this object.
 162     CSSToStyleMap m_styleMap;
 163     Vector<AtomicString> m_contentAttrValues;
 164
 165     StyleRule* m_currentRule;
 166 };
 167
 168 } // namespace WebCore
 169
 170 #endif // StyleResolverState_h