/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=2 et sw=2 tw=78: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ /* * a node in the lexicographic tree of rules that match an element, * responsible for converting the rules' information into computed style */ #include <algorithm> #include "mozilla/ArrayUtils.h" #include "mozilla/Assertions.h" #include "mozilla/DebugOnly.h" #include "mozilla/Function.h" #include "mozilla/dom/AnimationEffectReadOnlyBinding.h" // for PlaybackDirection #include "mozilla/Likely.h" #include "mozilla/LookAndFeel.h" #include "mozilla/OperatorNewExtensions.h" #include "mozilla/Unused.h" #include "mozilla/css/Declaration.h" #include "mozilla/TypeTraits.h" #include "nsAlgorithm.h" // for clamped() #include "nsRuleNode.h" #include "nscore.h" #include "nsIWidget.h" #include "nsIPresShell.h" #include "nsFontMetrics.h" #include "gfxFont.h" #include "nsCSSAnonBoxes.h" #include "nsCSSPseudoElements.h" #include "nsThemeConstants.h" #include "PLDHashTable.h" #include "nsStyleContext.h" #include "nsStyleSet.h" #include "nsStyleStruct.h" #include "nsSize.h" #include "nsRuleData.h" #include "nsIStyleRule.h" #include "nsBidiUtils.h" #include "nsStyleStructInlines.h" #include "nsCSSProps.h" #include "nsTArray.h" #include "nsContentUtils.h" #include "CSSCalc.h" #include "nsPrintfCString.h" #include "nsRenderingContext.h" #include "nsStyleUtil.h" #include "nsIDocument.h" #include "prtime.h" #include "CSSVariableResolver.h" #include "nsCSSParser.h" #include "CounterStyleManager.h" #include "nsCSSPropertyIDSet.h" #include "mozilla/RuleNodeCacheConditions.h" #include "nsDeviceContext.h" #include "nsQueryObject.h" #include "nsUnicodeProperties.h" #if defined(_MSC_VER) || defined(__MINGW32__) #include <malloc.h> #ifdef _MSC_VER #define alloca _alloca #endif #endif using std::max; using std::min; using namespace mozilla; using namespace mozilla::dom; namespace mozilla { enum UnsetAction { eUnsetInitial, eUnsetInherit }; } // namespace mozilla void* nsConditionalResetStyleData::GetConditionalStyleData(nsStyleStructID aSID, nsStyleContext* aStyleContext) const { Entry* e = static_cast<Entry*>(mEntries[aSID]); MOZ_ASSERT(e, "if mConditionalBits bit is set, we must have at least one " "conditional style struct"); do { if (e->mConditions.Matches(aStyleContext)) { void* data = e->mStyleStruct; // For reset structs with conditions, we cache the data on the // style context. // Tell the style context that it doesn't own the data aStyleContext->AddStyleBit(GetBitForSID(aSID)); aStyleContext->SetStyle(aSID, data); return data; } e = e->mNext; } while (e); return nullptr; } // Creates and returns an imgRequestProxy based on the specified // value in aValue. static imgRequestProxy* GetImageRequest(nsPresContext* aPresContext, const nsCSSValue& aValue) { return aValue.GetImageValue(aPresContext->Document()); } // Creates an imgRequestProxy based on the specified value in // aValue and calls aCallback with it. If the nsPresContext // is static (e.g. for printing), then a static request (i.e. // showing the first frame, without animation) will be created. // (The expectation is then that aCallback will set the resulting // imgRequestProxy in a style struct somewhere.) static void SetImageRequest(function<void(imgRequestProxy*)> aCallback, nsPresContext* aPresContext, const nsCSSValue& aValue) { RefPtr<imgRequestProxy> req = aValue.GetPossiblyStaticImageValue(aPresContext->Document(), aPresContext); aCallback(req); } static void SetStyleImageRequest(function<void(nsStyleImageRequest*)> aCallback, nsPresContext* aPresContext, const nsCSSValue& aValue, nsStyleImageRequest::Mode aModeFlags = nsStyleImageRequest::Mode::Track) { SetImageRequest([&](imgRequestProxy* aProxy) { RefPtr<nsStyleImageRequest> request; if (aProxy) { css::ImageValue* imageValue = aValue.GetImageStructValue(); ImageTracker* imageTracker = (aModeFlags & nsStyleImageRequest::Mode::Track) ? aPresContext->Document()->ImageTracker() : nullptr; request = new nsStyleImageRequest(aModeFlags, aProxy, imageValue, imageTracker); } aCallback(request); }, aPresContext, aValue); } template<typename ReferenceBox> static void SetStyleShapeSourceToCSSValue(StyleShapeSource<ReferenceBox>* aShapeSource, const nsCSSValue* aValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions); /* Helper function to convert a CSS <position> specified value into its * computed-style form. */ static void ComputePositionValue(nsStyleContext* aStyleContext, const nsCSSValue& aValue, Position& aComputedValue, RuleNodeCacheConditions& aConditions); /* * For storage of an |nsRuleNode|'s children in a PLDHashTable. */ struct ChildrenHashEntry : public PLDHashEntryHdr { // key is |mRuleNode->GetKey()| nsRuleNode *mRuleNode; }; /* static */ PLDHashNumber nsRuleNode::ChildrenHashHashKey(const void *aKey) { const nsRuleNode::Key *key = static_cast<const nsRuleNode::Key*>(aKey); // Disagreement on importance and level for the same rule is extremely // rare, so hash just on the rule. return PLDHashTable::HashVoidPtrKeyStub(key->mRule); } /* static */ bool nsRuleNode::ChildrenHashMatchEntry(const PLDHashEntryHdr *aHdr, const void *aKey) { const ChildrenHashEntry *entry = static_cast<const ChildrenHashEntry*>(aHdr); const nsRuleNode::Key *key = static_cast<const nsRuleNode::Key*>(aKey); return entry->mRuleNode->GetKey() == *key; } /* static */ const PLDHashTableOps nsRuleNode::ChildrenHashOps = { // It's probably better to allocate the table itself using malloc and // free rather than the pres shell's arena because the table doesn't // grow very often and the pres shell's arena doesn't recycle very // large size allocations. ChildrenHashHashKey, ChildrenHashMatchEntry, PLDHashTable::MoveEntryStub, PLDHashTable::ClearEntryStub, nullptr }; // EnsureBlockDisplay: // Never change display:none or display:contents *ever*, otherwise: // - if the display value (argument) is not a block-type // then we set it to a valid block display value // - For enforcing the floated/positioned element CSS2 rules // - We allow the behavior of "list-item" to be customized. // CSS21 says that position/float do not convert 'list-item' to 'block', // but it explicitly does not define whether 'list-item' should be // converted to block *on the root node*. To allow for flexibility // (so that we don't have to support a list-item root node), this method // lets the caller pick either behavior, using the 'aConvertListItem' arg. // Reference: http://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo /* static */ void nsRuleNode::EnsureBlockDisplay(StyleDisplay& display, bool aConvertListItem /* = false */) { // see if the display value is already a block switch (display) { case StyleDisplay::ListItem: if (aConvertListItem) { display = StyleDisplay::Block; break; } // else, fall through to share the 'break' for non-changing display vals MOZ_FALLTHROUGH; case StyleDisplay::None: case StyleDisplay::Contents: // never change display:none or display:contents *ever* case StyleDisplay::Table: case StyleDisplay::Block: case StyleDisplay::Flex: case StyleDisplay::WebkitBox: case StyleDisplay::Grid: // do not muck with these at all - already blocks // This is equivalent to nsStyleDisplay::IsBlockOutside. (XXX Maybe we // should just call that?) // This needs to match the check done in // nsCSSFrameConstructor::FindMathMLData for <math>. break; case StyleDisplay::InlineTable: // make inline tables into tables display = StyleDisplay::Table; break; case StyleDisplay::InlineFlex: // make inline flex containers into flex containers display = StyleDisplay::Flex; break; case StyleDisplay::WebkitInlineBox: // make -webkit-inline-box containers into -webkit-box containers display = StyleDisplay::WebkitBox; break; case StyleDisplay::InlineGrid: // make inline grid containers into grid containers display = StyleDisplay::Grid; break; default: // make it a block display = StyleDisplay::Block; } } // EnsureInlineDisplay: // - if the display value (argument) is not an inline type // then we set it to a valid inline display value /* static */ void nsRuleNode::EnsureInlineDisplay(StyleDisplay& display) { // see if the display value is already inline switch (display) { case StyleDisplay::Block: display = StyleDisplay::InlineBlock; break; case StyleDisplay::Table: display = StyleDisplay::InlineTable; break; case StyleDisplay::Flex: display = StyleDisplay::InlineFlex; break; case StyleDisplay::WebkitBox: display = StyleDisplay::WebkitInlineBox; break; case StyleDisplay::Grid: display = StyleDisplay::InlineGrid; break; case StyleDisplay::Box: display = StyleDisplay::InlineBox; break; case StyleDisplay::Stack: display = StyleDisplay::InlineStack; break; default: break; // Do nothing } } static nscoord CalcLengthWith(const nsCSSValue& aValue, nscoord aFontSize, const nsStyleFont* aStyleFont, nsStyleContext* aStyleContext, nsPresContext* aPresContext, bool aUseProvidedRootEmSize, bool aUseUserFontSet, RuleNodeCacheConditions& aConditions); struct CalcLengthCalcOps : public css::BasicCoordCalcOps, public css::NumbersAlreadyNormalizedOps { // All of the parameters to CalcLengthWith except aValue. const nscoord mFontSize; const nsStyleFont* const mStyleFont; nsStyleContext* const mStyleContext; nsPresContext* const mPresContext; const bool mUseProvidedRootEmSize; const bool mUseUserFontSet; RuleNodeCacheConditions& mConditions; CalcLengthCalcOps(nscoord aFontSize, const nsStyleFont* aStyleFont, nsStyleContext* aStyleContext, nsPresContext* aPresContext, bool aUseProvidedRootEmSize, bool aUseUserFontSet, RuleNodeCacheConditions& aConditions) : mFontSize(aFontSize), mStyleFont(aStyleFont), mStyleContext(aStyleContext), mPresContext(aPresContext), mUseProvidedRootEmSize(aUseProvidedRootEmSize), mUseUserFontSet(aUseUserFontSet), mConditions(aConditions) { } result_type ComputeLeafValue(const nsCSSValue& aValue) { return CalcLengthWith(aValue, mFontSize, mStyleFont, mStyleContext, mPresContext, mUseProvidedRootEmSize, mUseUserFontSet, mConditions); } }; static inline nscoord ScaleCoordRound(const nsCSSValue& aValue, float aFactor) { return NSToCoordRoundWithClamp(aValue.GetFloatValue() * aFactor); } static inline nscoord ScaleViewportCoordTrunc(const nsCSSValue& aValue, nscoord aViewportSize) { // For units (like percentages and viewport units) where authors might // repeatedly use a value and expect some multiple of the value to be // smaller than a container, we need to use floor rather than round. // We need to use division by 100.0 rather than multiplication by 0.1f // to avoid introducing error. return NSToCoordTruncClamped(aValue.GetFloatValue() * aViewportSize / 100.0f); } already_AddRefed<nsFontMetrics> GetMetricsFor(nsPresContext* aPresContext, nsStyleContext* aStyleContext, const nsStyleFont* aStyleFont, nscoord aFontSize, // overrides value from aStyleFont bool aUseUserFontSet) { nsFont font = aStyleFont->mFont; font.size = aFontSize; gfxFont::Orientation orientation = gfxFont::eHorizontal; if (aStyleContext) { WritingMode wm(aStyleContext); if (wm.IsVertical() && !wm.IsSideways()) { orientation = gfxFont::eVertical; } } nsFontMetrics::Params params; params.language = aStyleFont->mLanguage; params.explicitLanguage = aStyleFont->mExplicitLanguage; params.orientation = orientation; params.userFontSet = aUseUserFontSet ? aPresContext->GetUserFontSet() : nullptr; params.textPerf = aPresContext->GetTextPerfMetrics(); return aPresContext->DeviceContext()->GetMetricsFor(font, params); } static nsSize CalcViewportUnitsScale(nsPresContext* aPresContext) { // The caller is making use of viewport units, so notify the pres context // that it will need to rebuild the rule tree if the size of the viewport // changes. aPresContext->SetUsesViewportUnits(true); // The default (when we have 'overflow: auto' on the root element, or // trivially for 'overflow: hidden' since we never have scrollbars in that // case) is to define the scale of the viewport units without considering // scrollbars. nsSize viewportSize(aPresContext->GetVisibleArea().Size()); // Check for 'overflow: scroll' styles on the root scroll frame. If we find // any, the standard requires us to take scrollbars into account. nsIScrollableFrame* scrollFrame = aPresContext->PresShell()->GetRootScrollFrameAsScrollable(); if (scrollFrame) { ScrollbarStyles styles(scrollFrame->GetScrollbarStyles()); if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL || styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) { // Gather scrollbar size information. nsRenderingContext context( aPresContext->PresShell()->CreateReferenceRenderingContext()); nsMargin sizes(scrollFrame->GetDesiredScrollbarSizes(aPresContext, &context)); if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) { // 'overflow-x: scroll' means we must consider the horizontal scrollbar, // which affects the scale of viewport height units. viewportSize.height -= sizes.TopBottom(); } if (styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) { // 'overflow-y: scroll' means we must consider the vertical scrollbar, // which affects the scale of viewport width units. viewportSize.width -= sizes.LeftRight(); } } } return viewportSize; } // If |aStyleFont| is nullptr, aStyleContext->StyleFont() is used. // // In case that |aValue| is rem unit, if |aStyleContext| is null, callers must // specify a valid |aStyleFont| and |aUseProvidedRootEmSize| must be true so // that we can get the length from |aStyleFont|. static nscoord CalcLengthWith(const nsCSSValue& aValue, nscoord aFontSize, const nsStyleFont* aStyleFont, nsStyleContext* aStyleContext, nsPresContext* aPresContext, bool aUseProvidedRootEmSize, // aUseUserFontSet should always be true // except when called from // CalcLengthWithInitialFont. bool aUseUserFontSet, RuleNodeCacheConditions& aConditions) { NS_ASSERTION(aValue.IsLengthUnit() || aValue.IsCalcUnit(), "not a length or calc unit"); NS_ASSERTION(aStyleFont || aStyleContext, "Must have style data"); NS_ASSERTION(aStyleContext || aUseProvidedRootEmSize, "Must have style context or specify aUseProvidedRootEmSize"); NS_ASSERTION(aPresContext, "Must have prescontext"); if (aValue.IsFixedLengthUnit()) { return aValue.GetFixedLength(aPresContext); } if (aValue.IsPixelLengthUnit()) { return aValue.GetPixelLength(); } if (aValue.IsCalcUnit()) { // For properties for which lengths are the *only* units accepted in // calc(), we can handle calc() here and just compute a final // result. We ensure that we don't get to this code for other // properties by not calling CalcLength in those cases: SetCoord // only calls CalcLength for a calc when it is appropriate to do so. CalcLengthCalcOps ops(aFontSize, aStyleFont, aStyleContext, aPresContext, aUseProvidedRootEmSize, aUseUserFontSet, aConditions); return css::ComputeCalc(aValue, ops); } switch (aValue.GetUnit()) { // nsPresContext::SetVisibleArea and // nsPresContext::MediaFeatureValuesChanged handle dynamic changes // of the basis for viewport units by rebuilding the rule tree and // style context tree. Not caching them in the rule tree wouldn't // be sufficient to handle these changes because we also need a way // to get rid of cached values in the style context tree without any // changes in specified style. We can either do this by not caching // in the rule tree and then throwing away the style context tree // for dynamic viewport size changes, or by allowing caching in the // rule tree and using the existing rebuild style data path that // throws away the style context and the rule tree. // Thus we do cache viewport units in the rule tree. This allows us // to benefit from the performance advantages of the rule tree // (e.g., faster dynamic changes on other things, like transforms) // and allows us not to need an additional code path, in exchange // for an increased cost to dynamic changes to the viewport size // when viewport units are in use. case eCSSUnit_ViewportWidth: { nscoord viewportWidth = CalcViewportUnitsScale(aPresContext).width; return ScaleViewportCoordTrunc(aValue, viewportWidth); } case eCSSUnit_ViewportHeight: { nscoord viewportHeight = CalcViewportUnitsScale(aPresContext).height; return ScaleViewportCoordTrunc(aValue, viewportHeight); } case eCSSUnit_ViewportMin: { nsSize vuScale(CalcViewportUnitsScale(aPresContext)); nscoord viewportMin = min(vuScale.width, vuScale.height); return ScaleViewportCoordTrunc(aValue, viewportMin); } case eCSSUnit_ViewportMax: { nsSize vuScale(CalcViewportUnitsScale(aPresContext)); nscoord viewportMax = max(vuScale.width, vuScale.height); return ScaleViewportCoordTrunc(aValue, viewportMax); } // While we could deal with 'rem' units correctly by simply not // caching any data that uses them in the rule tree, it's valuable // to store them in the rule tree (for faster dynamic changes of // other things). And since the font size of the root element // changes rarely, we instead handle dynamic changes to the root // element's font size by rebuilding all style data in // nsCSSFrameConstructor::RestyleElement. case eCSSUnit_RootEM: { aPresContext->SetUsesRootEMUnits(true); nscoord rootFontSize; // NOTE: Be very careful with |styleFont|, since we haven't added any // conditions to aConditions or set it to uncacheable yet, so we don't // want to introduce any dependencies on aStyleContext's data here. const nsStyleFont *styleFont = aStyleFont ? aStyleFont : aStyleContext->StyleFont(); if (aUseProvidedRootEmSize) { // We should use the provided aFontSize as the reference length to // scale. This only happens when we are calculating font-size or // an equivalent (scriptminsize or CalcLengthWithInitialFont) on // the root element, in which case aFontSize is already the // value we want. if (aFontSize == -1) { // XXX Should this be styleFont->mSize instead to avoid taking // minfontsize prefs into account? aFontSize = styleFont->mFont.size; } rootFontSize = aFontSize; } else if (aStyleContext && !aStyleContext->GetParent()) { // This is the root element (XXX we don't really know this, but // nsRuleNode::SetFont makes the same assumption!), so we should // use StyleFont on this context to get the root element's // font size. rootFontSize = styleFont->mFont.size; } else { // This is not the root element or we are calculating something other // than font size, so rem is relative to the root element's font size. // Find the root style context by walking up the style context tree. nsStyleContext* rootStyle = aStyleContext; while (rootStyle->GetParent()) { rootStyle = rootStyle->GetParent(); } const nsStyleFont *rootStyleFont = rootStyle->StyleFont(); rootFontSize = rootStyleFont->mFont.size; } return ScaleCoordRound(aValue, float(rootFontSize)); } default: // Fall through to the code for units that can't be stored in the // rule tree because they depend on font data. break; } // Common code for units that depend on the element's font data and // thus can't be stored in the rule tree: const nsStyleFont *styleFont = aStyleFont ? aStyleFont : aStyleContext->StyleFont(); if (aFontSize == -1) { // XXX Should this be styleFont->mSize instead to avoid taking minfontsize // prefs into account? aFontSize = styleFont->mFont.size; } switch (aValue.GetUnit()) { case eCSSUnit_EM: { if (aValue.GetFloatValue() == 0.0f) { // Don't call SetFontSizeDependency for '0em'. return 0; } // CSS2.1 specifies that this unit scales to the computed font // size, not the em-width in the font metrics, despite the name. aConditions.SetFontSizeDependency(aFontSize); return ScaleCoordRound(aValue, float(aFontSize)); } case eCSSUnit_XHeight: { aPresContext->SetUsesExChUnits(true); RefPtr<nsFontMetrics> fm = GetMetricsFor(aPresContext, aStyleContext, styleFont, aFontSize, aUseUserFontSet); aConditions.SetUncacheable(); return ScaleCoordRound(aValue, float(fm->XHeight())); } case eCSSUnit_Char: { aPresContext->SetUsesExChUnits(true); RefPtr<nsFontMetrics> fm = GetMetricsFor(aPresContext, aStyleContext, styleFont, aFontSize, aUseUserFontSet); gfxFloat zeroWidth = fm->GetThebesFontGroup()->GetFirstValidFont()-> GetMetrics(fm->Orientation()).zeroOrAveCharWidth; aConditions.SetUncacheable(); return ScaleCoordRound(aValue, ceil(aPresContext->AppUnitsPerDevPixel() * zeroWidth)); } default: NS_NOTREACHED("unexpected unit"); break; } return 0; } /* static */ nscoord nsRuleNode::CalcLength(const nsCSSValue& aValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { NS_ASSERTION(aStyleContext, "Must have style data"); return CalcLengthWith(aValue, -1, nullptr, aStyleContext, aPresContext, false, true, aConditions); } /* Inline helper function to redirect requests to CalcLength. */ static inline nscoord CalcLength(const nsCSSValue& aValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { return nsRuleNode::CalcLength(aValue, aStyleContext, aPresContext, aConditions); } /* static */ nscoord nsRuleNode::CalcLengthWithInitialFont(nsPresContext* aPresContext, const nsCSSValue& aValue) { nsStyleFont defaultFont(aPresContext); // FIXME: best language? RuleNodeCacheConditions conditions; return CalcLengthWith(aValue, -1, &defaultFont, nullptr, aPresContext, true, false, conditions); } struct LengthPercentPairCalcOps : public css::NumbersAlreadyNormalizedOps { typedef nsRuleNode::ComputedCalc result_type; LengthPercentPairCalcOps(nsStyleContext* aContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) : mContext(aContext), mPresContext(aPresContext), mConditions(aConditions), mHasPercent(false) {} nsStyleContext* mContext; nsPresContext* mPresContext; RuleNodeCacheConditions& mConditions; bool mHasPercent; result_type ComputeLeafValue(const nsCSSValue& aValue) { if (aValue.GetUnit() == eCSSUnit_Percent) { mHasPercent = true; return result_type(0, aValue.GetPercentValue()); } return result_type(CalcLength(aValue, mContext, mPresContext, mConditions), 0.0f); } result_type MergeAdditive(nsCSSUnit aCalcFunction, result_type aValue1, result_type aValue2) { if (aCalcFunction == eCSSUnit_Calc_Plus) { return result_type(NSCoordSaturatingAdd(aValue1.mLength, aValue2.mLength), aValue1.mPercent + aValue2.mPercent); } MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Minus, "min() and max() are not allowed in calc() on transform"); return result_type(NSCoordSaturatingSubtract(aValue1.mLength, aValue2.mLength, 0), aValue1.mPercent - aValue2.mPercent); } result_type MergeMultiplicativeL(nsCSSUnit aCalcFunction, float aValue1, result_type aValue2) { MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Times_L, "unexpected unit"); return result_type(NSCoordSaturatingMultiply(aValue2.mLength, aValue1), aValue1 * aValue2.mPercent); } result_type MergeMultiplicativeR(nsCSSUnit aCalcFunction, result_type aValue1, float aValue2) { MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Times_R || aCalcFunction == eCSSUnit_Calc_Divided, "unexpected unit"); if (aCalcFunction == eCSSUnit_Calc_Divided) { aValue2 = 1.0f / aValue2; } return result_type(NSCoordSaturatingMultiply(aValue1.mLength, aValue2), aValue1.mPercent * aValue2); } }; static void SpecifiedCalcToComputedCalc(const nsCSSValue& aValue, nsStyleCoord& aCoord, nsStyleContext* aStyleContext, RuleNodeCacheConditions& aConditions) { LengthPercentPairCalcOps ops(aStyleContext, aStyleContext->PresContext(), aConditions); nsRuleNode::ComputedCalc vals = ComputeCalc(aValue, ops); nsStyleCoord::Calc* calcObj = new nsStyleCoord::Calc; calcObj->mLength = vals.mLength; calcObj->mPercent = vals.mPercent; calcObj->mHasPercent = ops.mHasPercent; aCoord.SetCalcValue(calcObj); } /* static */ nsRuleNode::ComputedCalc nsRuleNode::SpecifiedCalcToComputedCalc(const nsCSSValue& aValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { LengthPercentPairCalcOps ops(aStyleContext, aPresContext, aConditions); return ComputeCalc(aValue, ops); } // This is our public API for handling calc() expressions that involve // percentages. /* static */ nscoord nsRuleNode::ComputeComputedCalc(const nsStyleCoord& aValue, nscoord aPercentageBasis) { nsStyleCoord::Calc* calc = aValue.GetCalcValue(); return calc->mLength + NSToCoordFloorClamped(aPercentageBasis * calc->mPercent); } /* static */ nscoord nsRuleNode::ComputeCoordPercentCalc(const nsStyleCoord& aCoord, nscoord aPercentageBasis) { switch (aCoord.GetUnit()) { case eStyleUnit_Coord: return aCoord.GetCoordValue(); case eStyleUnit_Percent: return NSToCoordFloorClamped(aPercentageBasis * aCoord.GetPercentValue()); case eStyleUnit_Calc: return ComputeComputedCalc(aCoord, aPercentageBasis); default: MOZ_ASSERT(false, "unexpected unit"); return 0; } } /* Given an enumerated value that represents a box position, converts it to * a float representing the percentage of the box it corresponds to. For * example, "center" becomes 0.5f. * * @param aEnumValue The enumerated value. * @return The float percent it corresponds to. */ static float GetFloatFromBoxPosition(int32_t aEnumValue) { switch (aEnumValue) { case NS_STYLE_IMAGELAYER_POSITION_LEFT: case NS_STYLE_IMAGELAYER_POSITION_TOP: return 0.0f; case NS_STYLE_IMAGELAYER_POSITION_RIGHT: case NS_STYLE_IMAGELAYER_POSITION_BOTTOM: return 1.0f; default: MOZ_FALLTHROUGH_ASSERT("unexpected box position value"); case NS_STYLE_IMAGELAYER_POSITION_CENTER: return 0.5f; } } #define SETCOORD_NORMAL 0x01 // N #define SETCOORD_AUTO 0x02 // A #define SETCOORD_INHERIT 0x04 // H #define SETCOORD_PERCENT 0x08 // P #define SETCOORD_FACTOR 0x10 // F #define SETCOORD_LENGTH 0x20 // L #define SETCOORD_INTEGER 0x40 // I #define SETCOORD_ENUMERATED 0x80 // E #define SETCOORD_NONE 0x100 // O #define SETCOORD_INITIAL_ZERO 0x200 #define SETCOORD_INITIAL_AUTO 0x400 #define SETCOORD_INITIAL_NONE 0x800 #define SETCOORD_INITIAL_NORMAL 0x1000 #define SETCOORD_INITIAL_HALF 0x2000 #define SETCOORD_INITIAL_HUNDRED_PCT 0x00004000 #define SETCOORD_INITIAL_FACTOR_ONE 0x00008000 #define SETCOORD_INITIAL_FACTOR_ZERO 0x00010000 #define SETCOORD_CALC_LENGTH_ONLY 0x00020000 #define SETCOORD_CALC_CLAMP_NONNEGATIVE 0x00040000 // modifier for CALC_LENGTH_ONLY #define SETCOORD_STORE_CALC 0x00080000 #define SETCOORD_BOX_POSITION 0x00100000 // exclusive with _ENUMERATED #define SETCOORD_ANGLE 0x00200000 #define SETCOORD_UNSET_INHERIT 0x00400000 #define SETCOORD_UNSET_INITIAL 0x00800000 #define SETCOORD_LP (SETCOORD_LENGTH | SETCOORD_PERCENT) #define SETCOORD_LH (SETCOORD_LENGTH | SETCOORD_INHERIT) #define SETCOORD_AH (SETCOORD_AUTO | SETCOORD_INHERIT) #define SETCOORD_LAH (SETCOORD_AUTO | SETCOORD_LENGTH | SETCOORD_INHERIT) #define SETCOORD_LPH (SETCOORD_LP | SETCOORD_INHERIT) #define SETCOORD_LPAH (SETCOORD_LP | SETCOORD_AH) #define SETCOORD_LPE (SETCOORD_LP | SETCOORD_ENUMERATED) #define SETCOORD_LPEH (SETCOORD_LPE | SETCOORD_INHERIT) #define SETCOORD_LPAEH (SETCOORD_LPAH | SETCOORD_ENUMERATED) #define SETCOORD_LPO (SETCOORD_LP | SETCOORD_NONE) #define SETCOORD_LPOH (SETCOORD_LPH | SETCOORD_NONE) #define SETCOORD_LPOEH (SETCOORD_LPOH | SETCOORD_ENUMERATED) #define SETCOORD_LE (SETCOORD_LENGTH | SETCOORD_ENUMERATED) #define SETCOORD_LEH (SETCOORD_LE | SETCOORD_INHERIT) #define SETCOORD_IA (SETCOORD_INTEGER | SETCOORD_AUTO) #define SETCOORD_LAE (SETCOORD_LENGTH | SETCOORD_AUTO | SETCOORD_ENUMERATED) // changes aCoord iff it returns true static bool SetCoord(const nsCSSValue& aValue, nsStyleCoord& aCoord, const nsStyleCoord& aParentCoord, int32_t aMask, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { bool result = true; if (aValue.GetUnit() == eCSSUnit_Null) { result = false; } else if ((((aMask & SETCOORD_LENGTH) != 0) && aValue.IsLengthUnit()) || (((aMask & SETCOORD_CALC_LENGTH_ONLY) != 0) && aValue.IsCalcUnit())) { nscoord len = CalcLength(aValue, aStyleContext, aPresContext, aConditions); if ((aMask & SETCOORD_CALC_CLAMP_NONNEGATIVE) && len < 0) { NS_ASSERTION(aValue.IsCalcUnit(), "parser should have ensured no nonnegative lengths"); len = 0; } aCoord.SetCoordValue(len); } else if (((aMask & SETCOORD_PERCENT) != 0) && (aValue.GetUnit() == eCSSUnit_Percent)) { aCoord.SetPercentValue(aValue.GetPercentValue()); } else if (((aMask & SETCOORD_INTEGER) != 0) && (aValue.GetUnit() == eCSSUnit_Integer)) { aCoord.SetIntValue(aValue.GetIntValue(), eStyleUnit_Integer); } else if (((aMask & SETCOORD_ENUMERATED) != 0) && (aValue.GetUnit() == eCSSUnit_Enumerated)) { aCoord.SetIntValue(aValue.GetIntValue(), eStyleUnit_Enumerated); } else if (((aMask & SETCOORD_BOX_POSITION) != 0) && (aValue.GetUnit() == eCSSUnit_Enumerated)) { aCoord.SetPercentValue(GetFloatFromBoxPosition(aValue.GetIntValue())); } else if (((aMask & SETCOORD_AUTO) != 0) && (aValue.GetUnit() == eCSSUnit_Auto)) { aCoord.SetAutoValue(); } else if ((((aMask & SETCOORD_INHERIT) != 0) && aValue.GetUnit() == eCSSUnit_Inherit) || (((aMask & SETCOORD_UNSET_INHERIT) != 0) && aValue.GetUnit() == eCSSUnit_Unset)) { aCoord = aParentCoord; // just inherit value from parent aConditions.SetUncacheable(); } else if (((aMask & SETCOORD_NORMAL) != 0) && (aValue.GetUnit() == eCSSUnit_Normal)) { aCoord.SetNormalValue(); } else if (((aMask & SETCOORD_NONE) != 0) && (aValue.GetUnit() == eCSSUnit_None)) { aCoord.SetNoneValue(); } else if (((aMask & SETCOORD_FACTOR) != 0) && (aValue.GetUnit() == eCSSUnit_Number)) { aCoord.SetFactorValue(aValue.GetFloatValue()); } else if (((aMask & SETCOORD_STORE_CALC) != 0) && (aValue.IsCalcUnit())) { SpecifiedCalcToComputedCalc(aValue, aCoord, aStyleContext, aConditions); } else if (aValue.GetUnit() == eCSSUnit_Initial || (aValue.GetUnit() == eCSSUnit_Unset && ((aMask & SETCOORD_UNSET_INITIAL) != 0))) { if ((aMask & SETCOORD_INITIAL_AUTO) != 0) { aCoord.SetAutoValue(); } else if ((aMask & SETCOORD_INITIAL_ZERO) != 0) { aCoord.SetCoordValue(0); } else if ((aMask & SETCOORD_INITIAL_FACTOR_ZERO) != 0) { aCoord.SetFactorValue(0.0f); } else if ((aMask & SETCOORD_INITIAL_NONE) != 0) { aCoord.SetNoneValue(); } else if ((aMask & SETCOORD_INITIAL_NORMAL) != 0) { aCoord.SetNormalValue(); } else if ((aMask & SETCOORD_INITIAL_HALF) != 0) { aCoord.SetPercentValue(0.5f); } else if ((aMask & SETCOORD_INITIAL_HUNDRED_PCT) != 0) { aCoord.SetPercentValue(1.0f); } else if ((aMask & SETCOORD_INITIAL_FACTOR_ONE) != 0) { aCoord.SetFactorValue(1.0f); } else { result = false; // didn't set anything } } else if ((aMask & SETCOORD_ANGLE) != 0 && (aValue.IsAngularUnit())) { nsStyleUnit unit; switch (aValue.GetUnit()) { case eCSSUnit_Degree: unit = eStyleUnit_Degree; break; case eCSSUnit_Grad: unit = eStyleUnit_Grad; break; case eCSSUnit_Radian: unit = eStyleUnit_Radian; break; case eCSSUnit_Turn: unit = eStyleUnit_Turn; break; default: NS_NOTREACHED("unrecognized angular unit"); unit = eStyleUnit_Degree; } aCoord.SetAngleValue(aValue.GetAngleValue(), unit); } else { result = false; // didn't set anything } return result; } // This inline function offers a shortcut for SetCoord() by refusing to accept // SETCOORD_LENGTH, SETCOORD_INHERIT and SETCOORD_UNSET_* masks. static inline bool SetAbsCoord(const nsCSSValue& aValue, nsStyleCoord& aCoord, int32_t aMask) { MOZ_ASSERT((aMask & (SETCOORD_LH | SETCOORD_UNSET_INHERIT | SETCOORD_UNSET_INITIAL)) == 0, "does not handle SETCOORD_LENGTH, SETCOORD_INHERIT and " "SETCOORD_UNSET_*"); // The values of the following variables will never be used; so it does not // matter what to set. const nsStyleCoord dummyParentCoord; nsStyleContext* dummyStyleContext = nullptr; nsPresContext* dummyPresContext = nullptr; RuleNodeCacheConditions dummyCacheKey; bool rv = SetCoord(aValue, aCoord, dummyParentCoord, aMask, dummyStyleContext, dummyPresContext, dummyCacheKey); MOZ_ASSERT(dummyCacheKey.CacheableWithoutDependencies(), "SetCoord() should not modify dummyCacheKey."); return rv; } /* Given a specified value that might be a pair value, call SetCoord twice, * either using each member of the pair, or using the unpaired value twice. */ static bool SetPairCoords(const nsCSSValue& aValue, nsStyleCoord& aCoordX, nsStyleCoord& aCoordY, const nsStyleCoord& aParentX, const nsStyleCoord& aParentY, int32_t aMask, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { const nsCSSValue& valX = aValue.GetUnit() == eCSSUnit_Pair ? aValue.GetPairValue().mXValue : aValue; const nsCSSValue& valY = aValue.GetUnit() == eCSSUnit_Pair ? aValue.GetPairValue().mYValue : aValue; bool cX = SetCoord(valX, aCoordX, aParentX, aMask, aStyleContext, aPresContext, aConditions); mozilla::DebugOnly<bool> cY = SetCoord(valY, aCoordY, aParentY, aMask, aStyleContext, aPresContext, aConditions); MOZ_ASSERT(cX == cY, "changed one but not the other"); return cX; } static bool SetColor(const nsCSSValue& aValue, const nscolor aParentColor, nsPresContext* aPresContext, nsStyleContext *aContext, nscolor& aResult, RuleNodeCacheConditions& aConditions) { bool result = false; nsCSSUnit unit = aValue.GetUnit(); if (aValue.IsNumericColorUnit()) { aResult = aValue.GetColorValue(); result = true; } else if (eCSSUnit_Ident == unit) { nsAutoString value; aValue.GetStringValue(value); nscolor rgba; if (NS_ColorNameToRGB(value, &rgba)) { aResult = rgba; result = true; } } else if (eCSSUnit_EnumColor == unit) { int32_t intValue = aValue.GetIntValue(); if (0 <= intValue) { LookAndFeel::ColorID colorID = (LookAndFeel::ColorID) intValue; bool useStandinsForNativeColors = aPresContext && !aPresContext->IsChrome(); if (NS_SUCCEEDED(LookAndFeel::GetColor(colorID, useStandinsForNativeColors, &aResult))) { result = true; } } else { aResult = NS_RGB(0, 0, 0); result = false; switch (intValue) { case NS_COLOR_MOZ_HYPERLINKTEXT: if (aPresContext) { aResult = aPresContext->DefaultLinkColor(); result = true; } break; case NS_COLOR_MOZ_VISITEDHYPERLINKTEXT: if (aPresContext) { aResult = aPresContext->DefaultVisitedLinkColor(); result = true; } break; case NS_COLOR_MOZ_ACTIVEHYPERLINKTEXT: if (aPresContext) { aResult = aPresContext->DefaultActiveLinkColor(); result = true; } break; case NS_COLOR_CURRENTCOLOR: // The data computed from this can't be shared in the rule tree // because they could be used on a node with a different color aConditions.SetUncacheable(); if (aContext) { aResult = aContext->StyleColor()->mColor; result = true; } break; case NS_COLOR_MOZ_DEFAULT_COLOR: if (aPresContext) { aResult = aPresContext->DefaultColor(); result = true; } break; case NS_COLOR_MOZ_DEFAULT_BACKGROUND_COLOR: if (aPresContext) { aResult = aPresContext->DefaultBackgroundColor(); result = true; } break; default: NS_NOTREACHED("Should never have an unknown negative colorID."); break; } } } else if (eCSSUnit_Inherit == unit) { aResult = aParentColor; result = true; aConditions.SetUncacheable(); } else if (eCSSUnit_Enumerated == unit && aValue.GetIntValue() == NS_STYLE_COLOR_INHERIT_FROM_BODY) { NS_ASSERTION(aPresContext->CompatibilityMode() == eCompatibility_NavQuirks, "Should only get this value in quirks mode"); // We just grab the color from the prescontext, and rely on the fact that // if the body color ever changes all its descendants will get new style // contexts (but NOT necessarily new rulenodes). aResult = aPresContext->BodyTextColor(); result = true; aConditions.SetUncacheable(); } return result; } template<UnsetAction UnsetTo> static void SetComplexColor(const nsCSSValue& aValue, const StyleComplexColor& aParentColor, const StyleComplexColor& aInitialColor, nsPresContext* aPresContext, StyleComplexColor& aResult, RuleNodeCacheConditions& aConditions) { nsCSSUnit unit = aValue.GetUnit(); if (unit == eCSSUnit_Null) { return; } if (unit == eCSSUnit_Initial || (UnsetTo == eUnsetInitial && unit == eCSSUnit_Unset)) { aResult = aInitialColor; } else if (unit == eCSSUnit_Inherit || (UnsetTo == eUnsetInherit && unit == eCSSUnit_Unset)) { aConditions.SetUncacheable(); aResult = aParentColor; } else if (unit == eCSSUnit_EnumColor && aValue.GetIntValue() == NS_COLOR_CURRENTCOLOR) { aResult = StyleComplexColor::CurrentColor(); } else if (unit == eCSSUnit_ComplexColor) { aResult = aValue.GetStyleComplexColorValue(); } else { if (!SetColor(aValue, aParentColor.mColor, aPresContext, nullptr, aResult.mColor, aConditions)) { MOZ_ASSERT_UNREACHABLE("Unknown color value"); return; } aResult.mForegroundRatio = 0; } } static void SetGradientCoord(const nsCSSValue& aValue, nsPresContext* aPresContext, nsStyleContext* aContext, nsStyleCoord& aResult, RuleNodeCacheConditions& aConditions) { // OK to pass bad aParentCoord since we're not passing SETCOORD_INHERIT if (!SetCoord(aValue, aResult, nsStyleCoord(), SETCOORD_LPO | SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC, aContext, aPresContext, aConditions)) { NS_NOTREACHED("unexpected unit for gradient anchor point"); aResult.SetNoneValue(); } } static void SetGradient(const nsCSSValue& aValue, nsPresContext* aPresContext, nsStyleContext* aContext, nsStyleGradient& aResult, RuleNodeCacheConditions& aConditions) { MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Gradient, "The given data is not a gradient"); const nsCSSValueGradient* gradient = aValue.GetGradientValue(); if (gradient->mIsExplicitSize) { SetCoord(gradient->GetRadiusX(), aResult.mRadiusX, nsStyleCoord(), SETCOORD_LP | SETCOORD_STORE_CALC, aContext, aPresContext, aConditions); if (gradient->GetRadiusY().GetUnit() != eCSSUnit_None) { SetCoord(gradient->GetRadiusY(), aResult.mRadiusY, nsStyleCoord(), SETCOORD_LP | SETCOORD_STORE_CALC, aContext, aPresContext, aConditions); aResult.mShape = NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL; } else { aResult.mRadiusY = aResult.mRadiusX; aResult.mShape = NS_STYLE_GRADIENT_SHAPE_CIRCULAR; } aResult.mSize = NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE; } else if (gradient->mIsRadial) { if (gradient->GetRadialShape().GetUnit() == eCSSUnit_Enumerated) { aResult.mShape = gradient->GetRadialShape().GetIntValue(); } else { NS_ASSERTION(gradient->GetRadialShape().GetUnit() == eCSSUnit_None, "bad unit for radial shape"); aResult.mShape = NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL; } if (gradient->GetRadialSize().GetUnit() == eCSSUnit_Enumerated) { aResult.mSize = gradient->GetRadialSize().GetIntValue(); } else { NS_ASSERTION(gradient->GetRadialSize().GetUnit() == eCSSUnit_None, "bad unit for radial shape"); aResult.mSize = NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER; } } else { NS_ASSERTION(gradient->GetRadialShape().GetUnit() == eCSSUnit_None, "bad unit for linear shape"); NS_ASSERTION(gradient->GetRadialSize().GetUnit() == eCSSUnit_None, "bad unit for linear size"); aResult.mShape = NS_STYLE_GRADIENT_SHAPE_LINEAR; aResult.mSize = NS_STYLE_GRADIENT_SIZE_FARTHEST_CORNER; } aResult.mLegacySyntax = gradient->mIsLegacySyntax; // bg-position SetGradientCoord(gradient->mBgPos.mXValue, aPresContext, aContext, aResult.mBgPosX, aConditions); SetGradientCoord(gradient->mBgPos.mYValue, aPresContext, aContext, aResult.mBgPosY, aConditions); aResult.mRepeating = gradient->mIsRepeating; // angle const nsStyleCoord dummyParentCoord; if (!SetCoord(gradient->mAngle, aResult.mAngle, dummyParentCoord, SETCOORD_ANGLE, aContext, aPresContext, aConditions)) { NS_ASSERTION(gradient->mAngle.GetUnit() == eCSSUnit_None, "bad unit for gradient angle"); aResult.mAngle.SetNoneValue(); } // stops for (uint32_t i = 0; i < gradient->mStops.Length(); i++) { nsStyleGradientStop stop; const nsCSSValueGradientStop &valueStop = gradient->mStops[i]; if (!SetCoord(valueStop.mLocation, stop.mLocation, nsStyleCoord(), SETCOORD_LPO | SETCOORD_STORE_CALC, aContext, aPresContext, aConditions)) { NS_NOTREACHED("unexpected unit for gradient stop location"); } stop.mIsInterpolationHint = valueStop.mIsInterpolationHint; // inherit is not a valid color for stops, so we pass in a dummy // parent color NS_ASSERTION(valueStop.mColor.GetUnit() != eCSSUnit_Inherit, "inherit is not a valid color for gradient stops"); if (!valueStop.mIsInterpolationHint) { SetColor(valueStop.mColor, NS_RGB(0, 0, 0), aPresContext, aContext, stop.mColor, aConditions); } else { // Always initialize to the same color so we don't need to worry // about comparisons. stop.mColor = NS_RGB(0, 0, 0); } aResult.mStops.AppendElement(stop); } } // -moz-image-rect(<uri>, <top>, <right>, <bottom>, <left>) static void SetStyleImageToImageRect(nsStyleContext* aStyleContext, const nsCSSValue& aValue, nsStyleImage& aResult) { MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Function && aValue.EqualsFunction(eCSSKeyword__moz_image_rect), "the value is not valid -moz-image-rect()"); nsCSSValue::Array* arr = aValue.GetArrayValue(); MOZ_ASSERT(arr && arr->Count() == 6, "invalid number of arguments"); // <uri> if (arr->Item(1).GetUnit() == eCSSUnit_Image) { SetStyleImageRequest([&](nsStyleImageRequest* req) { aResult.SetImageRequest(do_AddRef(req)); }, aStyleContext->PresContext(), arr->Item(1)); } else { NS_WARNING("nsCSSValue::Image::Image() failed?"); } // <top>, <right>, <bottom>, <left> nsStyleSides cropRect; NS_FOR_CSS_SIDES(side) { nsStyleCoord coord; const nsCSSValue& val = arr->Item(2 + side); #ifdef DEBUG bool unitOk = #endif SetAbsCoord(val, coord, SETCOORD_FACTOR | SETCOORD_PERCENT); MOZ_ASSERT(unitOk, "Incorrect data structure created by CSS parser"); cropRect.Set(side, coord); } aResult.SetCropRect(MakeUnique<nsStyleSides>(cropRect)); } static void SetStyleImage(nsStyleContext* aStyleContext, const nsCSSValue& aValue, nsStyleImage& aResult, RuleNodeCacheConditions& aConditions) { if (aValue.GetUnit() == eCSSUnit_Null) { return; } aResult.SetNull(); switch (aValue.GetUnit()) { case eCSSUnit_Image: SetStyleImageRequest([&](nsStyleImageRequest* req) { aResult.SetImageRequest(do_AddRef(req)); }, aStyleContext->PresContext(), aValue); break; case eCSSUnit_Function: if (aValue.EqualsFunction(eCSSKeyword__moz_image_rect)) { SetStyleImageToImageRect(aStyleContext, aValue, aResult); } else { NS_NOTREACHED("-moz-image-rect() is the only expected function"); } break; case eCSSUnit_Gradient: { nsStyleGradient* gradient = new nsStyleGradient(); SetGradient(aValue, aStyleContext->PresContext(), aStyleContext, *gradient, aConditions); aResult.SetGradientData(gradient); break; } case eCSSUnit_Element: aResult.SetElementId(aValue.GetStringBufferValue()); break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: break; case eCSSUnit_URL: { #ifdef DEBUG // eCSSUnit_URL is expected only if // 1. we have eCSSUnit_URL values for if-visited style contexts, which // we can safely treat like 'none'. // 2. aValue is a local-ref URL, e.g. url(#foo). // 3. aValue is a not a local-ref URL, but it refers to an element in // the current document. For example, the url of the current document // is "http://foo.html" and aValue is url(http://foo.html#foo). // // We skip image download in TryToStartImageLoadOnValue under #2 and #3, // and that's part of reasons we get eCSSUnit_URL instead of // eCSSUnit_Image here. // Check #2. bool isLocalRef = aValue.GetURLStructValue()->IsLocalRef(); // Check #3. bool isEqualExceptRef = false; if (!isLocalRef) { nsIDocument* currentDoc = aStyleContext->PresContext()->Document(); nsIURI* docURI = currentDoc->GetDocumentURI(); nsIURI* imageURI = aValue.GetURLValue(); imageURI->EqualsExceptRef(docURI, &isEqualExceptRef); } MOZ_ASSERT(aStyleContext->IsStyleIfVisited() || isEqualExceptRef || isLocalRef, "unexpected unit; maybe nsCSSValue::Image::Image() failed?"); #endif break; } default: MOZ_ASSERT_UNREACHABLE("Unexpected Unit type."); break; } } struct SetEnumValueHelper { template<typename FieldT> static void SetIntegerValue(FieldT&, const nsCSSValue&) { // FIXME Is it possible to turn this assertion into a compilation error? MOZ_ASSERT_UNREACHABLE("inappropriate unit"); } #define DEFINE_ENUM_CLASS_SETTER(type_, min_, max_) \ static void SetEnumeratedValue(type_& aField, const nsCSSValue& aValue) \ { \ auto value = aValue.GetIntValue(); \ MOZ_ASSERT(value >= static_cast<decltype(value)>(type_::min_) && \ value <= static_cast<decltype(value)>(type_::max_), \ "inappropriate value"); \ aField = static_cast<type_>(value); \ } DEFINE_ENUM_CLASS_SETTER(StyleBoxAlign, Stretch, End) DEFINE_ENUM_CLASS_SETTER(StyleBoxDecorationBreak, Slice, Clone) DEFINE_ENUM_CLASS_SETTER(StyleBoxDirection, Normal, Reverse) DEFINE_ENUM_CLASS_SETTER(StyleBoxOrient, Horizontal, Vertical) DEFINE_ENUM_CLASS_SETTER(StyleBoxPack, Start, Justify) DEFINE_ENUM_CLASS_SETTER(StyleBoxSizing, Content, Border) DEFINE_ENUM_CLASS_SETTER(StyleClear, None, Both) DEFINE_ENUM_CLASS_SETTER(StyleFillRule, Nonzero, Evenodd) DEFINE_ENUM_CLASS_SETTER(StyleFloat, None, InlineEnd) DEFINE_ENUM_CLASS_SETTER(StyleFloatEdge, ContentBox, MarginBox) DEFINE_ENUM_CLASS_SETTER(StyleTextJustify, None, InterCharacter) DEFINE_ENUM_CLASS_SETTER(StyleUserFocus, None, SelectMenu) DEFINE_ENUM_CLASS_SETTER(StyleUserSelect, None, MozText) DEFINE_ENUM_CLASS_SETTER(StyleUserInput, None, Auto) DEFINE_ENUM_CLASS_SETTER(StyleUserModify, ReadOnly, WriteOnly) DEFINE_ENUM_CLASS_SETTER(StyleWindowDragging, Default, NoDrag) DEFINE_ENUM_CLASS_SETTER(StyleOrient, Inline, Vertical) #ifdef MOZ_XUL DEFINE_ENUM_CLASS_SETTER(StyleDisplay, None, Popup) #else DEFINE_ENUM_CLASS_SETTER(StyleDisplay, None, InlineBox) #endif #undef DEF_SET_ENUMERATED_VALUE }; template<typename FieldT> struct SetIntegerValueHelper { static void SetIntegerValue(FieldT& aField, const nsCSSValue& aValue) { aField = aValue.GetIntValue(); } static void SetEnumeratedValue(FieldT& aField, const nsCSSValue& aValue) { aField = aValue.GetIntValue(); } }; template<typename FieldT> struct SetValueHelper : Conditional<IsEnum<FieldT>::value, SetEnumValueHelper, SetIntegerValueHelper<FieldT>>::Type { template<typename ValueT> static void SetValue(FieldT& aField, const ValueT& aValue) { aField = aValue; } static void SetValue(FieldT&, unused_t) { // FIXME Is it possible to turn this assertion into a compilation error? MOZ_ASSERT_UNREACHABLE("inappropriate unit"); } }; // flags for SetValue - align values with SETCOORD_* constants // where possible #define SETVAL_INTEGER 0x40 // I #define SETVAL_ENUMERATED 0x80 // E #define SETVAL_UNSET_INHERIT 0x00400000 #define SETVAL_UNSET_INITIAL 0x00800000 // no caller cares whether aField was changed or not template<typename FieldT, typename InitialT, typename AutoT, typename NoneT, typename NormalT, typename SysFontT> static void SetValue(const nsCSSValue& aValue, FieldT& aField, RuleNodeCacheConditions& aConditions, uint32_t aMask, FieldT aParentValue, InitialT aInitialValue, AutoT aAutoValue, NoneT aNoneValue, NormalT aNormalValue, SysFontT aSystemFontValue) { typedef SetValueHelper<FieldT> Helper; switch (aValue.GetUnit()) { case eCSSUnit_Null: return; // every caller of SetValue provides inherit and initial // alternatives, so we don't require them to say so in the mask case eCSSUnit_Inherit: aConditions.SetUncacheable(); aField = aParentValue; return; case eCSSUnit_Initial: Helper::SetValue(aField, aInitialValue); return; // every caller provides one or other of these alternatives, // but they have to say which case eCSSUnit_Enumerated: if (aMask & SETVAL_ENUMERATED) { Helper::SetEnumeratedValue(aField, aValue); return; } break; case eCSSUnit_Integer: if (aMask & SETVAL_INTEGER) { Helper::SetIntegerValue(aField, aValue); return; } break; // remaining possibilities in descending order of frequency of use case eCSSUnit_Auto: Helper::SetValue(aField, aAutoValue); return; case eCSSUnit_None: Helper::SetValue(aField, aNoneValue); return; case eCSSUnit_Normal: Helper::SetValue(aField, aNormalValue); return; case eCSSUnit_System_Font: Helper::SetValue(aField, aSystemFontValue); return; case eCSSUnit_Unset: if (aMask & SETVAL_UNSET_INHERIT) { aConditions.SetUncacheable(); aField = aParentValue; return; } if (aMask & SETVAL_UNSET_INITIAL) { Helper::SetValue(aField, aInitialValue); return; } break; default: break; } NS_NOTREACHED("SetValue: inappropriate unit"); } template <typename FieldT, typename T1> static void SetValue(const nsCSSValue& aValue, FieldT& aField, RuleNodeCacheConditions& aConditions, uint32_t aMask, FieldT aParentValue, T1 aInitialValue) { SetValue(aValue, aField, aConditions, aMask, aParentValue, aInitialValue, Unused, Unused, Unused, Unused); } // flags for SetFactor #define SETFCT_POSITIVE 0x01 // assert value is >= 0.0f #define SETFCT_OPACITY 0x02 // clamp value to [0.0f .. 1.0f] #define SETFCT_NONE 0x04 // allow _None (uses aInitialValue). #define SETFCT_UNSET_INHERIT 0x00400000 #define SETFCT_UNSET_INITIAL 0x00800000 static void SetFactor(const nsCSSValue& aValue, float& aField, RuleNodeCacheConditions& aConditions, float aParentValue, float aInitialValue, uint32_t aFlags = 0) { switch (aValue.GetUnit()) { case eCSSUnit_Null: return; case eCSSUnit_Number: aField = aValue.GetFloatValue(); if (aFlags & SETFCT_POSITIVE) { NS_ASSERTION(aField >= 0.0f, "negative value for positive-only property"); if (aField < 0.0f) aField = 0.0f; } if (aFlags & SETFCT_OPACITY) { if (aField < 0.0f) aField = 0.0f; if (aField > 1.0f) aField = 1.0f; } return; case eCSSUnit_Inherit: aConditions.SetUncacheable(); aField = aParentValue; return; case eCSSUnit_Initial: aField = aInitialValue; return; case eCSSUnit_None: if (aFlags & SETFCT_NONE) { aField = aInitialValue; return; } break; case eCSSUnit_Unset: if (aFlags & SETFCT_UNSET_INHERIT) { aConditions.SetUncacheable(); aField = aParentValue; return; } if (aFlags & SETFCT_UNSET_INITIAL) { aField = aInitialValue; return; } break; default: break; } NS_NOTREACHED("SetFactor: inappropriate unit"); } void* nsRuleNode::operator new(size_t sz, nsPresContext* aPresContext) { // Check the recycle list first. return aPresContext->PresShell()->AllocateByObjectID(eArenaObjectID_nsRuleNode, sz); } // Overridden to prevent the global delete from being called, since the memory // came out of an nsIArena instead of the global delete operator's heap. void nsRuleNode::Destroy() { // Destroy ourselves. this->~nsRuleNode(); // Don't let the memory be freed, since it will be recycled // instead. Don't call the global operator delete. mPresContext->PresShell()->FreeByObjectID(eArenaObjectID_nsRuleNode, this); } already_AddRefed<nsRuleNode> nsRuleNode::CreateRootNode(nsPresContext* aPresContext) { return do_AddRef(new (aPresContext) nsRuleNode(aPresContext, nullptr, nullptr, SheetType::Unknown, false)); } nsRuleNode::nsRuleNode(nsPresContext* aContext, nsRuleNode* aParent, nsIStyleRule* aRule, SheetType aLevel, bool aIsImportant) : mPresContext(aContext), mParent(aParent), mRule(aRule), mNextSibling(nullptr), mDependentBits((uint32_t(aLevel) << NS_RULE_NODE_LEVEL_SHIFT) | (aIsImportant ? NS_RULE_NODE_IS_IMPORTANT : 0)), mNoneBits(aParent ? aParent->mNoneBits & NS_RULE_NODE_HAS_ANIMATION_DATA : 0), mRefCnt(0) { MOZ_ASSERT(aContext); MOZ_ASSERT(IsRoot() == !aRule, "non-root rule nodes must have a rule"); mChildren.asVoid = nullptr; MOZ_COUNT_CTOR(nsRuleNode); NS_ASSERTION(IsRoot() || GetLevel() == aLevel, "not enough bits"); NS_ASSERTION(IsRoot() || IsImportantRule() == aIsImportant, "yikes"); MOZ_ASSERT(aContext->StyleSet()->IsGecko(), "ServoStyleSets should not have rule nodes"); aContext->StyleSet()->AsGecko()->RuleNodeUnused(this, /* aMayGC = */ false); // nsStyleSet::GetContext depends on there being only one animation // rule. MOZ_ASSERT(IsRoot() || GetLevel() != SheetType::Animation || mParent->IsRoot() || mParent->GetLevel() != SheetType::Animation, "must be only one rule at animation level"); } nsRuleNode::~nsRuleNode() { MOZ_ASSERT(!HaveChildren()); MOZ_COUNT_DTOR(nsRuleNode); if (mParent) { mParent->RemoveChild(this); } if (mStyleData.mResetData || mStyleData.mInheritedData) mStyleData.Destroy(mDependentBits, mPresContext); } nsRuleNode* nsRuleNode::Transition(nsIStyleRule* aRule, SheetType aLevel, bool aIsImportantRule) { #ifdef DEBUG { RefPtr<css::Declaration> declaration(do_QueryObject(aRule)); MOZ_ASSERT(!declaration || !declaration->IsMutable(), "caller must call Declaration::SetImmutable first"); } #endif nsRuleNode* next = nullptr; nsRuleNode::Key key(aRule, aLevel, aIsImportantRule); if (HaveChildren() && !ChildrenAreHashed()) { int32_t numKids = 0; nsRuleNode* curr = ChildrenList(); while (curr && curr->GetKey() != key) { curr = curr->mNextSibling; ++numKids; } if (curr) next = curr; else if (numKids >= kMaxChildrenInList) ConvertChildrenToHash(numKids); } if (ChildrenAreHashed()) { auto entry = static_cast<ChildrenHashEntry*>(ChildrenHash()->Add(&key, fallible)); if (!entry) { NS_WARNING("out of memory"); return this; } if (entry->mRuleNode) next = entry->mRuleNode; else { next = entry->mRuleNode = new (mPresContext) nsRuleNode(mPresContext, this, aRule, aLevel, aIsImportantRule); } } else if (!next) { // Create the new entry in our list. next = new (mPresContext) nsRuleNode(mPresContext, this, aRule, aLevel, aIsImportantRule); next->mNextSibling = ChildrenList(); SetChildrenList(next); } return next; } nsRuleNode* nsRuleNode::RuleTree() { nsRuleNode* n = this; while (n->mParent) { n = n->mParent; } return n; } void nsRuleNode::SetUsedDirectly() { mDependentBits |= NS_RULE_NODE_USED_DIRECTLY; // Maintain the invariant that any rule node that is used directly has // all structs that live in the rule tree cached (which // nsRuleNode::GetStyleData depends on for speed). if (mDependentBits & NS_STYLE_INHERIT_MASK) { for (nsStyleStructID sid = nsStyleStructID(0); sid < nsStyleStructID_Length; sid = nsStyleStructID(sid + 1)) { uint32_t bit = nsCachedStyleData::GetBitForSID(sid); if (mDependentBits & bit) { nsRuleNode *source = mParent; while ((source->mDependentBits & bit) && !source->IsUsedDirectly()) { source = source->mParent; } void *data = source->mStyleData.GetStyleData(sid); NS_ASSERTION(data, "unexpected null struct"); mStyleData.SetStyleData(sid, mPresContext, data); } } } } void nsRuleNode::ConvertChildrenToHash(int32_t aNumKids) { NS_ASSERTION(!ChildrenAreHashed() && HaveChildren(), "must have a non-empty list of children"); PLDHashTable *hash = new PLDHashTable(&ChildrenHashOps, sizeof(ChildrenHashEntry), aNumKids); for (nsRuleNode* curr = ChildrenList(); curr; curr = curr->mNextSibling) { Key key = curr->GetKey(); // This will never fail because of the initial size we gave the table. auto entry = static_cast<ChildrenHashEntry*>(hash->Add(&key)); NS_ASSERTION(!entry->mRuleNode, "duplicate entries in list"); entry->mRuleNode = curr; } SetChildrenHash(hash); } void nsRuleNode::RemoveChild(nsRuleNode* aNode) { MOZ_ASSERT(HaveChildren()); if (ChildrenAreHashed()) { PLDHashTable* children = ChildrenHash(); Key key = aNode->GetKey(); MOZ_ASSERT(children->Search(&key)); children->Remove(&key); if (children->EntryCount() == 0) { delete children; mChildren.asVoid = nullptr; } } else { // This linear traversal is unfortunate, but we do the same thing when // adding nodes. The traversal is bounded by kMaxChildrenInList. nsRuleNode** curr = &mChildren.asList; while (*curr != aNode) { curr = &((*curr)->mNextSibling); MOZ_ASSERT(*curr); } *curr = (*curr)->mNextSibling; // If there was one element in the list, this sets mChildren.asList // to 0, and HaveChildren() will return false. } } inline void nsRuleNode::PropagateNoneBit(uint32_t aBit, nsRuleNode* aHighestNode) { nsRuleNode* curr = this; for (;;) { NS_ASSERTION(!(curr->mNoneBits & aBit), "propagating too far"); curr->mNoneBits |= aBit; if (curr == aHighestNode) break; curr = curr->mParent; } } inline void nsRuleNode::PropagateDependentBit(nsStyleStructID aSID, nsRuleNode* aHighestNode, void* aStruct) { NS_ASSERTION(aStruct, "expected struct"); uint32_t bit = nsCachedStyleData::GetBitForSID(aSID); for (nsRuleNode* curr = this; curr != aHighestNode; curr = curr->mParent) { if (curr->mDependentBits & bit) { #ifdef DEBUG while (curr != aHighestNode) { NS_ASSERTION(curr->mDependentBits & bit, "bit not set"); curr = curr->mParent; } #endif break; } curr->mDependentBits |= bit; if (curr->IsUsedDirectly()) { curr->mStyleData.SetStyleData(aSID, mPresContext, aStruct); } } } /* static */ void nsRuleNode::PropagateGrandancestorBit(nsStyleContext* aContext, nsStyleContext* aContextInheritedFrom) { MOZ_ASSERT(aContext); MOZ_ASSERT(aContextInheritedFrom && aContextInheritedFrom != aContext, "aContextInheritedFrom must be an ancestor of aContext"); for (nsStyleContext* context = aContext->GetParent(); context != aContextInheritedFrom; context = context->GetParent()) { if (!context) { MOZ_ASSERT(false, "aContextInheritedFrom must be an ancestor of " "aContext's parent"); break; } context->AddStyleBit(NS_STYLE_CHILD_USES_GRANDANCESTOR_STYLE); } } /* * The following "Check" functions are used for determining what type of * sharing can be used for the data on this rule node. MORE HERE... */ /* * a callback function that that can revise the result of * CheckSpecifiedProperties before finishing; aResult is the current * result, and it returns the revised one. */ typedef nsRuleNode::RuleDetail (* CheckCallbackFn)(const nsRuleData* aRuleData, nsRuleNode::RuleDetail aResult); /** * @param aValue the value being examined * @param aSpecifiedCount to be incremented by one if the value is specified * @param aInheritedCount to be incremented by one if the value is set to inherit * @param aUnsetCount to be incremented by one if the value is set to unset */ inline void ExamineCSSValue(const nsCSSValue& aValue, uint32_t& aSpecifiedCount, uint32_t& aInheritedCount, uint32_t& aUnsetCount) { if (aValue.GetUnit() != eCSSUnit_Null) { ++aSpecifiedCount; if (aValue.GetUnit() == eCSSUnit_Inherit) { ++aInheritedCount; } else if (aValue.GetUnit() == eCSSUnit_Unset) { ++aUnsetCount; } } } static nsRuleNode::RuleDetail CheckFontCallback(const nsRuleData* aRuleData, nsRuleNode::RuleDetail aResult) { // em, ex, percent, 'larger', and 'smaller' values on font-size depend // on the parent context's font-size // Likewise, 'lighter' and 'bolder' values of 'font-weight', and 'wider' // and 'narrower' values of 'font-stretch' depend on the parent. const nsCSSValue& size = *aRuleData->ValueForFontSize(); const nsCSSValue& weight = *aRuleData->ValueForFontWeight(); if ((size.IsRelativeLengthUnit() && size.GetUnit() != eCSSUnit_RootEM) || size.GetUnit() == eCSSUnit_Percent || (size.GetUnit() == eCSSUnit_Enumerated && (size.GetIntValue() == NS_STYLE_FONT_SIZE_SMALLER || size.GetIntValue() == NS_STYLE_FONT_SIZE_LARGER)) || aRuleData->ValueForScriptLevel()->GetUnit() == eCSSUnit_Integer || (weight.GetUnit() == eCSSUnit_Enumerated && (weight.GetIntValue() == NS_STYLE_FONT_WEIGHT_BOLDER || weight.GetIntValue() == NS_STYLE_FONT_WEIGHT_LIGHTER))) { NS_ASSERTION(aResult == nsRuleNode::eRulePartialReset || aResult == nsRuleNode::eRuleFullReset || aResult == nsRuleNode::eRulePartialMixed || aResult == nsRuleNode::eRuleFullMixed, "we know we already have a reset-counted property"); // Promote reset to mixed since we have something that depends on // the parent. But never promote to inherited since that could // cause inheritance of the exact value. if (aResult == nsRuleNode::eRulePartialReset) aResult = nsRuleNode::eRulePartialMixed; else if (aResult == nsRuleNode::eRuleFullReset) aResult = nsRuleNode::eRuleFullMixed; } return aResult; } static nsRuleNode::RuleDetail CheckColorCallback(const nsRuleData* aRuleData, nsRuleNode::RuleDetail aResult) { // currentColor values for color require inheritance const nsCSSValue* colorValue = aRuleData->ValueForColor(); if (colorValue->GetUnit() == eCSSUnit_EnumColor && colorValue->GetIntValue() == NS_COLOR_CURRENTCOLOR) { NS_ASSERTION(aResult == nsRuleNode::eRuleFullReset, "we should already be counted as full-reset"); aResult = nsRuleNode::eRuleFullInherited; } return aResult; } static nsRuleNode::RuleDetail CheckTextCallback(const nsRuleData* aRuleData, nsRuleNode::RuleDetail aResult) { const nsCSSValue* textAlignValue = aRuleData->ValueForTextAlign(); if (textAlignValue->GetUnit() == eCSSUnit_Enumerated && (textAlignValue->GetIntValue() == NS_STYLE_TEXT_ALIGN_MOZ_CENTER_OR_INHERIT || textAlignValue->GetIntValue() == NS_STYLE_TEXT_ALIGN_MATCH_PARENT)) { // Promote reset to mixed since we have something that depends on // the parent. if (aResult == nsRuleNode::eRulePartialReset) aResult = nsRuleNode::eRulePartialMixed; else if (aResult == nsRuleNode::eRuleFullReset) aResult = nsRuleNode::eRuleFullMixed; } return aResult; } static nsRuleNode::RuleDetail CheckVariablesCallback(const nsRuleData* aRuleData, nsRuleNode::RuleDetail aResult) { // We don't actually have any properties on nsStyleVariables, so we do // all of the RuleDetail calculation in here. if (aRuleData->mVariables) { return nsRuleNode::eRulePartialMixed; } return nsRuleNode::eRuleNone; } #define FLAG_DATA_FOR_PROPERTY(name_, id_, method_, flags_, pref_, \ parsevariant_, kwtable_, stylestructoffset_, \ animtype_) \ flags_, // The order here must match the enums in *CheckCounter in nsCSSProps.cpp. static const uint32_t gFontFlags[] = { #define CSS_PROP_FONT FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_FONT }; static const uint32_t gDisplayFlags[] = { #define CSS_PROP_DISPLAY FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_DISPLAY }; static const uint32_t gVisibilityFlags[] = { #define CSS_PROP_VISIBILITY FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_VISIBILITY }; static const uint32_t gMarginFlags[] = { #define CSS_PROP_MARGIN FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_MARGIN }; static const uint32_t gBorderFlags[] = { #define CSS_PROP_BORDER FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_BORDER }; static const uint32_t gPaddingFlags[] = { #define CSS_PROP_PADDING FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_PADDING }; static const uint32_t gOutlineFlags[] = { #define CSS_PROP_OUTLINE FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_OUTLINE }; static const uint32_t gListFlags[] = { #define CSS_PROP_LIST FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_LIST }; static const uint32_t gColorFlags[] = { #define CSS_PROP_COLOR FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_COLOR }; static const uint32_t gBackgroundFlags[] = { #define CSS_PROP_BACKGROUND FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_BACKGROUND }; static const uint32_t gPositionFlags[] = { #define CSS_PROP_POSITION FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_POSITION }; static const uint32_t gTableFlags[] = { #define CSS_PROP_TABLE FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_TABLE }; static const uint32_t gTableBorderFlags[] = { #define CSS_PROP_TABLEBORDER FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_TABLEBORDER }; static const uint32_t gContentFlags[] = { #define CSS_PROP_CONTENT FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_CONTENT }; static const uint32_t gTextFlags[] = { #define CSS_PROP_TEXT FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_TEXT }; static const uint32_t gTextResetFlags[] = { #define CSS_PROP_TEXTRESET FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_TEXTRESET }; static const uint32_t gUserInterfaceFlags[] = { #define CSS_PROP_USERINTERFACE FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_USERINTERFACE }; static const uint32_t gUIResetFlags[] = { #define CSS_PROP_UIRESET FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_UIRESET }; static const uint32_t gXULFlags[] = { #define CSS_PROP_XUL FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_XUL }; static const uint32_t gSVGFlags[] = { #define CSS_PROP_SVG FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_SVG }; static const uint32_t gSVGResetFlags[] = { #define CSS_PROP_SVGRESET FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_SVGRESET }; static const uint32_t gColumnFlags[] = { #define CSS_PROP_COLUMN FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_COLUMN }; // There are no properties in nsStyleVariables, but we can't have a // zero length array. static const uint32_t gVariablesFlags[] = { 0, #define CSS_PROP_VARIABLES FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_VARIABLES }; static_assert(sizeof(gVariablesFlags) == sizeof(uint32_t), "if nsStyleVariables has properties now you can remove the dummy " "gVariablesFlags entry"); static const uint32_t gEffectsFlags[] = { #define CSS_PROP_EFFECTS FLAG_DATA_FOR_PROPERTY #include "nsCSSPropList.h" #undef CSS_PROP_EFFECTS }; #undef FLAG_DATA_FOR_PROPERTY static const uint32_t* gFlagsByStruct[] = { #define STYLE_STRUCT(name, checkdata_cb) \ g##name##Flags, #include "nsStyleStructList.h" #undef STYLE_STRUCT }; static const CheckCallbackFn gCheckCallbacks[] = { #define STYLE_STRUCT(name, checkdata_cb) \ checkdata_cb, #include "nsStyleStructList.h" #undef STYLE_STRUCT }; #ifdef DEBUG static bool AreAllMathMLPropertiesUndefined(const nsRuleData* aRuleData) { return aRuleData->ValueForScriptLevel()->GetUnit() == eCSSUnit_Null && aRuleData->ValueForScriptSizeMultiplier()->GetUnit() == eCSSUnit_Null && aRuleData->ValueForScriptMinSize()->GetUnit() == eCSSUnit_Null && aRuleData->ValueForMathVariant()->GetUnit() == eCSSUnit_Null && aRuleData->ValueForMathDisplay()->GetUnit() == eCSSUnit_Null; } #endif inline nsRuleNode::RuleDetail nsRuleNode::CheckSpecifiedProperties(const nsStyleStructID aSID, const nsRuleData* aRuleData) { // Build a count of the: uint32_t total = 0, // total number of props in the struct specified = 0, // number that were specified for this node inherited = 0, // number that were 'inherit' (and not // eCSSUnit_Inherit) for this node unset = 0; // number that were 'unset' // See comment in nsRuleData.h above mValueOffsets. MOZ_ASSERT(aRuleData->mValueOffsets[aSID] == 0, "we assume the value offset is zero instead of adding it"); for (nsCSSValue *values = aRuleData->mValueStorage, *values_end = values + nsCSSProps::PropertyCountInStruct(aSID); values != values_end; ++values) { ++total; ExamineCSSValue(*values, specified, inherited, unset); } if (!nsCachedStyleData::IsReset(aSID)) { // For inherited properties, 'unset' means the same as 'inherit'. inherited += unset; unset = 0; } #if 0 printf("CheckSpecifiedProperties: SID=%d total=%d spec=%d inh=%d.\n", aSID, total, specified, inherited); #endif NS_ASSERTION(aSID != eStyleStruct_Font || mPresContext->Document()->GetMathMLEnabled() || AreAllMathMLPropertiesUndefined(aRuleData), "MathML style property was defined even though MathML is disabled"); /* * Return the most specific information we can: prefer None or Full * over Partial, and Reset or Inherited over Mixed, since we can * optimize based on the edge cases and not the in-between cases. */ nsRuleNode::RuleDetail result; if (inherited == total) result = eRuleFullInherited; else if (specified == total // MathML defines 5 properties in Font that will never be set when // MathML is not in use. Therefore if all but five // properties have been set, and MathML is not enabled, we can treat // this as fully specified. Code in nsMathMLElementFactory will // rebuild the rule tree and style data when MathML is first enabled // (see nsMathMLElement::BindToTree). || (aSID == eStyleStruct_Font && specified + 5 == total && !mPresContext->Document()->GetMathMLEnabled()) ) { if (inherited == 0) result = eRuleFullReset; else result = eRuleFullMixed; } else if (specified == 0) result = eRuleNone; else if (specified == inherited) result = eRulePartialInherited; else if (inherited == 0) result = eRulePartialReset; else result = eRulePartialMixed; CheckCallbackFn cb = gCheckCallbacks[aSID]; if (cb) { result = (*cb)(aRuleData, result); } return result; } // If we need to restrict which properties apply to the style context, // return the bit to check in nsCSSProp's flags table. Otherwise, // return 0. inline uint32_t GetPseudoRestriction(nsStyleContext *aContext) { // This needs to match nsStyleSet::WalkRestrictionRule. uint32_t pseudoRestriction = 0; nsIAtom *pseudoType = aContext->GetPseudo(); if (pseudoType) { if (pseudoType == nsCSSPseudoElements::firstLetter) { pseudoRestriction = CSS_PROPERTY_APPLIES_TO_FIRST_LETTER; } else if (pseudoType == nsCSSPseudoElements::firstLine) { pseudoRestriction = CSS_PROPERTY_APPLIES_TO_FIRST_LINE; } else if (pseudoType == nsCSSPseudoElements::placeholder) { pseudoRestriction = CSS_PROPERTY_APPLIES_TO_PLACEHOLDER; } } return pseudoRestriction; } static void UnsetPropertiesWithoutFlags(const nsStyleStructID aSID, nsRuleData* aRuleData, uint32_t aFlags) { NS_ASSERTION(aFlags != 0, "aFlags must be nonzero"); const uint32_t *flagData = gFlagsByStruct[aSID]; // See comment in nsRuleData.h above mValueOffsets. MOZ_ASSERT(aRuleData->mValueOffsets[aSID] == 0, "we assume the value offset is zero instead of adding it"); nsCSSValue *values = aRuleData->mValueStorage; for (size_t i = 0, i_end = nsCSSProps::PropertyCountInStruct(aSID); i != i_end; ++i) { if ((flagData[i] & aFlags) != aFlags) values[i].Reset(); } } /** * We allocate arrays of CSS values with alloca. (These arrays are a * fixed size per style struct, but we don't want to waste the * allocation and construction/destruction costs of the big structs when * we're handling much smaller ones.) Since the lifetime of an alloca * allocation is the life of the calling function, the caller must call * alloca. However, to ensure that constructors and destructors are * balanced, we do the constructor and destructor calling from this RAII * class, AutoCSSValueArray. */ struct AutoCSSValueArray { /** * aStorage must be the result of alloca(aCount * sizeof(nsCSSValue)) */ AutoCSSValueArray(void* aStorage, size_t aCount) { MOZ_ASSERT(size_t(aStorage) % NS_ALIGNMENT_OF(nsCSSValue) == 0, "bad alignment from alloca"); mCount = aCount; // Don't use placement new[], since it might store extra data // for the count (on Windows!). mArray = static_cast<nsCSSValue*>(aStorage); for (size_t i = 0; i < mCount; ++i) { new (KnownNotNull, mArray + i) nsCSSValue(); } } ~AutoCSSValueArray() { for (size_t i = 0; i < mCount; ++i) { mArray[i].~nsCSSValue(); } } nsCSSValue* get() { return mArray; } private: nsCSSValue *mArray; size_t mCount; }; /* static */ bool nsRuleNode::ResolveVariableReferences(const nsStyleStructID aSID, nsRuleData* aRuleData, nsStyleContext* aContext) { MOZ_ASSERT(aSID != eStyleStruct_Variables); MOZ_ASSERT(aRuleData->mSIDs & nsCachedStyleData::GetBitForSID(aSID)); MOZ_ASSERT(aRuleData->mValueOffsets[aSID] == 0); nsCSSParser parser; bool anyTokenStreams = false; // Look at each property in the nsRuleData for the given style struct. size_t nprops = nsCSSProps::PropertyCountInStruct(aSID); for (nsCSSValue* value = aRuleData->mValueStorage, *values_end = aRuleData->mValueStorage + nprops; value != values_end; value++) { if (value->GetUnit() != eCSSUnit_TokenStream) { continue; } const CSSVariableValues* variables = &aContext->StyleVariables()->mVariables; nsCSSValueTokenStream* tokenStream = value->GetTokenStreamValue(); MOZ_ASSERT(tokenStream->mLevel != SheetType::Count, "Token stream should have a defined level"); AutoRestore<SheetType> saveLevel(aRuleData->mLevel); aRuleData->mLevel = tokenStream->mLevel; // Note that ParsePropertyWithVariableReferences relies on the fact // that the nsCSSValue in aRuleData for the property we are re-parsing // is still the token stream value. When // ParsePropertyWithVariableReferences calls // nsCSSExpandedDataBlock::MapRuleInfoInto, that function will add // the ImageValue that is created into the token stream object's // mImageValues table; see the comment above mImageValues for why. // XXX Should pass in sheet here (see bug 952338). parser.ParsePropertyWithVariableReferences( tokenStream->mPropertyID, tokenStream->mShorthandPropertyID, tokenStream->mTokenStream, variables, aRuleData, tokenStream->mSheetURI, tokenStream->mBaseURI, tokenStream->mSheetPrincipal, nullptr, tokenStream->mLineNumber, tokenStream->mLineOffset); aRuleData->mConditions.SetUncacheable(); anyTokenStreams = true; } return anyTokenStreams; } const void* nsRuleNode::WalkRuleTree(const nsStyleStructID aSID, nsStyleContext* aContext) { // use placement new[] on the result of alloca() to allocate a // variable-sized stack array, including execution of constructors, // and use an RAII class to run the destructors too. size_t nprops = nsCSSProps::PropertyCountInStruct(aSID); void* dataStorage = alloca(nprops * sizeof(nsCSSValue)); AutoCSSValueArray dataArray(dataStorage, nprops); nsRuleData ruleData(nsCachedStyleData::GetBitForSID(aSID), dataArray.get(), mPresContext, aContext); ruleData.mValueOffsets[aSID] = 0; // We start at the most specific rule in the tree. void* startStruct = nullptr; nsRuleNode* ruleNode = this; nsRuleNode* highestNode = nullptr; // The highest node in the rule tree // that has the same properties // specified for struct |aSID| as // |this| does. nsRuleNode* rootNode = this; // After the loop below, this will be the // highest node that we've walked without // finding cached data on the rule tree. // If we don't find any cached data, it // will be the root. (XXX misnamed) RuleDetail detail = eRuleNone; uint32_t bit = nsCachedStyleData::GetBitForSID(aSID); while (ruleNode) { // See if this rule node has cached the fact that the remaining // nodes along this path specify no data whatsoever. if (ruleNode->mNoneBits & bit) break; // If the dependent bit is set on a rule node for this struct, that // means its rule won't have any information to add, so skip it. // NOTE: If we exit the loop because of the !IsUsedDirectly() check, // then we're guaranteed to break immediately afterwards due to a // non-null startStruct. while ((ruleNode->mDependentBits & bit) && !ruleNode->IsUsedDirectly()) { NS_ASSERTION(ruleNode->mStyleData.GetStyleData(aSID) == nullptr, "dependent bit with cached data makes no sense"); // Climb up to the next rule in the tree (a less specific rule). rootNode = ruleNode; ruleNode = ruleNode->mParent; NS_ASSERTION(!(ruleNode->mNoneBits & bit), "can't have both bits set"); } // Check for cached data after the inner loop above -- otherwise // we'll miss it. startStruct = ruleNode->mStyleData.GetStyleData(aSID); if (startStruct) break; // We found a rule with fully specified data. We don't // need to go up the tree any further, since the remainder // of this branch has already been computed. // Ask the rule to fill in the properties that it specifies. nsIStyleRule *rule = ruleNode->mRule; if (rule) { ruleData.mLevel = ruleNode->GetLevel(); ruleData.mIsImportantRule = ruleNode->IsImportantRule(); rule->MapRuleInfoInto(&ruleData); } // Now we check to see how many properties have been specified by // the rules we've examined so far. RuleDetail oldDetail = detail; detail = CheckSpecifiedProperties(aSID, &ruleData); if (oldDetail == eRuleNone && detail != eRuleNone) highestNode = ruleNode; if (detail == eRuleFullReset || detail == eRuleFullMixed || detail == eRuleFullInherited) break; // We don't need to examine any more rules. All properties // have been fully specified. // Climb up to the next rule in the tree (a less specific rule). rootNode = ruleNode; ruleNode = ruleNode->mParent; } bool recomputeDetail = false; // If we are computing a style struct other than nsStyleVariables, and // ruleData has any properties with variable references (nsCSSValues of // type eCSSUnit_TokenStream), then we need to resolve these. if (aSID != eStyleStruct_Variables) { // A property's value might have became 'inherit' after resolving // variable references. (This happens when an inherited property // fails to parse its resolved value.) We need to recompute // |detail| in case this happened. recomputeDetail = ResolveVariableReferences(aSID, &ruleData, aContext); } // If needed, unset the properties that don't have a flag that allows // them to be set for this style context. (For example, only some // properties apply to :first-line and :first-letter.) uint32_t pseudoRestriction = GetPseudoRestriction(aContext); if (pseudoRestriction) { UnsetPropertiesWithoutFlags(aSID, &ruleData, pseudoRestriction); // We need to recompute |detail| based on the restrictions we just applied. // We can adjust |detail| arbitrarily because of the restriction // rule added in nsStyleSet::WalkRestrictionRule. recomputeDetail = true; } if (recomputeDetail) { detail = CheckSpecifiedProperties(aSID, &ruleData); } NS_ASSERTION(!startStruct || (detail != eRuleFullReset && detail != eRuleFullMixed && detail != eRuleFullInherited), "can't have start struct and be fully specified"); bool isReset = nsCachedStyleData::IsReset(aSID); if (!highestNode) highestNode = rootNode; MOZ_ASSERT(!(aSID == eStyleStruct_Variables && startStruct), "if we start caching Variables structs in the rule tree, then " "not forcing detail to eRulePartialMixed just below is no " "longer valid"); if (detail == eRuleNone && isReset) { // We specified absolutely no rule information for a reset struct, and we // may or may not have found a parent rule in the tree that specified all // the rule information. Regardless, we don't need to use any cache // conditions if we cache this struct in the rule tree. // // Normally ruleData.mConditions would already indicate that the struct // is cacheable without conditions if detail is eRuleNone, but because // of the UnsetPropertiesWithoutFlags call above, we may have encountered // some rules with dependencies, which we then cleared out of ruleData. // // ruleData.mConditions could also indicate we are not cacheable at all, // such as when AnimValuesStyleRule prevents us from caching structs // when attempting to apply animations to pseudos. // // So if we we are uncacheable, we leave it, but if we are cacheable // with dependencies, we convert that to cacheable without dependencies. if (ruleData.mConditions.CacheableWithDependencies()) { MOZ_ASSERT(pseudoRestriction, "should only be cacheable with dependencies if we had a " "pseudo restriction"); ruleData.mConditions.Clear(); } else { // XXXheycam We shouldn't have `|| GetLevel() == SheetType::Transition` // in the assertion condition, but rule nodes created by // ResolveStyleByAddingRules don't call SetIsAnimationRule(). MOZ_ASSERT(ruleData.mConditions.CacheableWithoutDependencies() || ((HasAnimationData() || GetLevel() == SheetType::Transition) && aContext->GetParent() && aContext->GetParent()->HasPseudoElementData()), "should only be uncacheable if we had an animation rule " "and we're inside a pseudo"); } } if (!ruleData.mConditions.CacheableWithoutDependencies() && aSID != eStyleStruct_Variables) { // Treat as though some data is specified to avoid the optimizations and // force data computation. // // We don't need to do this for Variables structs since we know those are // never cached in the rule tree, and it avoids wasteful computation of a // new Variables struct when we have no additional variable declarations, // which otherwise could happen when there is an AnimValuesStyleRule // (which calls SetUncacheable for style contexts with pseudo data). detail = eRulePartialMixed; } if (detail == eRuleNone && startStruct) { // We specified absolutely no rule information, but a parent rule in the tree // specified all the rule information. We set a bit along the branch from our // node in the tree to the node that specified the data that tells nodes on that // branch that they never need to examine their rules for this particular struct type // ever again. PropagateDependentBit(aSID, ruleNode, startStruct); // For inherited structs, mark the struct (which will be set on // the context by our caller) as not being owned by the context. if (!isReset) { aContext->AddStyleBit(nsCachedStyleData::GetBitForSID(aSID)); } else if (HasAnimationData()) { // If we have animation data, the struct should be cached on the style // context so that we can peek the struct. // See comment in AnimValuesStyleRule::MapRuleInfoInto. StoreStyleOnContext(aContext, aSID, startStruct); } return startStruct; } if ((!startStruct && !isReset && (detail == eRuleNone || detail == eRulePartialInherited)) || detail == eRuleFullInherited) { // We specified no non-inherited information and neither did any of // our parent rules. // We set a bit along the branch from the highest node (ruleNode) // down to our node (this) indicating that no non-inherited data was // specified. This bit is guaranteed to be set already on the path // from the highest node to the root node in the case where // (detail == eRuleNone), which is the most common case here. // We must check |!isReset| because the Compute*Data functions for // reset structs wouldn't handle none bits correctly. if (highestNode != this && !isReset) PropagateNoneBit(bit, highestNode); // All information must necessarily be inherited from our parent style context. // In the absence of any computed data in the rule tree and with // no rules specified that didn't have values of 'inherit', we should check our parent. nsStyleContext* parentContext = aContext->GetParent(); if (isReset) { /* Reset structs don't inherit from first-line. */ /* See similar code in COMPUTE_START_RESET */ while (parentContext && parentContext->GetPseudo() == nsCSSPseudoElements::firstLine) { parentContext = parentContext->GetParent(); } if (parentContext && parentContext != aContext->GetParent()) { PropagateGrandancestorBit(aContext, parentContext); } } if (parentContext) { // We have a parent, and so we should just inherit from the parent. // Set the inherit bits on our context. These bits tell the style context that // it never has to go back to the rule tree for data. Instead the style context tree // should be walked to find the data. const void* parentStruct = parentContext->StyleData(aSID); aContext->AddStyleBit(bit); // makes const_cast OK. aContext->SetStyle(aSID, const_cast<void*>(parentStruct)); if (isReset) { parentContext->AddStyleBit(NS_STYLE_HAS_CHILD_THAT_USES_RESET_STYLE); } return parentStruct; } else // We are the root. In the case of fonts, the default values just // come from the pres context. return SetDefaultOnRoot(aSID, aContext); } typedef const void* (nsRuleNode::*ComputeFunc)(void*, const nsRuleData*, nsStyleContext*, nsRuleNode*, RuleDetail, const RuleNodeCacheConditions); static const ComputeFunc sComputeFuncs[] = { #define STYLE_STRUCT(name, checkdata_cb) &nsRuleNode::Compute##name##Data, #include "nsStyleStructList.h" #undef STYLE_STRUCT }; // We need to compute the data from the information that the rules specified. return (this->*sComputeFuncs[aSID])(startStruct, &ruleData, aContext, highestNode, detail, ruleData.mConditions); } const void* nsRuleNode::SetDefaultOnRoot(const nsStyleStructID aSID, nsStyleContext* aContext) { switch (aSID) { case eStyleStruct_Font: { nsStyleFont* fontData = new (mPresContext) nsStyleFont(mPresContext); nscoord minimumFontSize = mPresContext->MinFontSize(fontData->mLanguage); if (minimumFontSize > 0 && !mPresContext->IsChrome()) { fontData->mFont.size = std::max(fontData->mSize, minimumFontSize); } else { fontData->mFont.size = fontData->mSize; } aContext->SetStyle(eStyleStruct_Font, fontData); return fontData; } case eStyleStruct_Display: { nsStyleDisplay* disp = new (mPresContext) nsStyleDisplay(mPresContext); aContext->SetStyle(eStyleStruct_Display, disp); return disp; } case eStyleStruct_Visibility: { nsStyleVisibility* vis = new (mPresContext) nsStyleVisibility(mPresContext); aContext->SetStyle(eStyleStruct_Visibility, vis); return vis; } case eStyleStruct_Text: { nsStyleText* text = new (mPresContext) nsStyleText(mPresContext); aContext->SetStyle(eStyleStruct_Text, text); return text; } case eStyleStruct_TextReset: { nsStyleTextReset* text = new (mPresContext) nsStyleTextReset(mPresContext); aContext->SetStyle(eStyleStruct_TextReset, text); return text; } case eStyleStruct_Color: { nsStyleColor* color = new (mPresContext) nsStyleColor(mPresContext); aContext->SetStyle(eStyleStruct_Color, color); return color; } case eStyleStruct_Background: { nsStyleBackground* bg = new (mPresContext) nsStyleBackground(mPresContext); aContext->SetStyle(eStyleStruct_Background, bg); return bg; } case eStyleStruct_Margin: { nsStyleMargin* margin = new (mPresContext) nsStyleMargin(mPresContext); aContext->SetStyle(eStyleStruct_Margin, margin); return margin; } case eStyleStruct_Border: { nsStyleBorder* border = new (mPresContext) nsStyleBorder(mPresContext); aContext->SetStyle(eStyleStruct_Border, border); return border; } case eStyleStruct_Padding: { nsStylePadding* padding = new (mPresContext) nsStylePadding(mPresContext); aContext->SetStyle(eStyleStruct_Padding, padding); return padding; } case eStyleStruct_Outline: { nsStyleOutline* outline = new (mPresContext) nsStyleOutline(mPresContext); aContext->SetStyle(eStyleStruct_Outline, outline); return outline; } case eStyleStruct_List: { nsStyleList* list = new (mPresContext) nsStyleList(mPresContext); aContext->SetStyle(eStyleStruct_List, list); return list; } case eStyleStruct_Position: { nsStylePosition* pos = new (mPresContext) nsStylePosition(mPresContext); aContext->SetStyle(eStyleStruct_Position, pos); return pos; } case eStyleStruct_Table: { nsStyleTable* table = new (mPresContext) nsStyleTable(mPresContext); aContext->SetStyle(eStyleStruct_Table, table); return table; } case eStyleStruct_TableBorder: { nsStyleTableBorder* table = new (mPresContext) nsStyleTableBorder(mPresContext); aContext->SetStyle(eStyleStruct_TableBorder, table); return table; } case eStyleStruct_Content: { nsStyleContent* content = new (mPresContext) nsStyleContent(mPresContext); aContext->SetStyle(eStyleStruct_Content, content); return content; } case eStyleStruct_UserInterface: { nsStyleUserInterface* ui = new (mPresContext) nsStyleUserInterface(mPresContext); aContext->SetStyle(eStyleStruct_UserInterface, ui); return ui; } case eStyleStruct_UIReset: { nsStyleUIReset* ui = new (mPresContext) nsStyleUIReset(mPresContext); aContext->SetStyle(eStyleStruct_UIReset, ui); return ui; } case eStyleStruct_XUL: { nsStyleXUL* xul = new (mPresContext) nsStyleXUL(mPresContext); aContext->SetStyle(eStyleStruct_XUL, xul); return xul; } case eStyleStruct_Column: { nsStyleColumn* column = new (mPresContext) nsStyleColumn(mPresContext); aContext->SetStyle(eStyleStruct_Column, column); return column; } case eStyleStruct_SVG: { nsStyleSVG* svg = new (mPresContext) nsStyleSVG(mPresContext); aContext->SetStyle(eStyleStruct_SVG, svg); return svg; } case eStyleStruct_SVGReset: { nsStyleSVGReset* svgReset = new (mPresContext) nsStyleSVGReset(mPresContext); aContext->SetStyle(eStyleStruct_SVGReset, svgReset); return svgReset; } case eStyleStruct_Variables: { nsStyleVariables* vars = new (mPresContext) nsStyleVariables(mPresContext); aContext->SetStyle(eStyleStruct_Variables, vars); return vars; } case eStyleStruct_Effects: { nsStyleEffects* effects = new (mPresContext) nsStyleEffects(mPresContext); aContext->SetStyle(eStyleStruct_Effects, effects); return effects; } default: /* * unhandled case: nsStyleStructID_Length. * last item of nsStyleStructID, to know its length. */ MOZ_ASSERT(false, "unexpected SID"); return nullptr; } return nullptr; } /** * Begin an nsRuleNode::Compute*Data function for an inherited struct. * * @param type_ The nsStyle* type this function computes. * @param data_ Variable (declared here) holding the result of this * function. * @param parentdata_ Variable (declared here) holding the parent style * context's data for this struct. */ #define COMPUTE_START_INHERITED(type_, data_, parentdata_) \ NS_ASSERTION(aRuleDetail != eRuleFullInherited, \ "should not have bothered calling Compute*Data"); \ \ nsStyleContext* parentContext = aContext->GetParent(); \ \ nsStyle##type_* data_ = nullptr; \ mozilla::Maybe<nsStyle##type_> maybeFakeParentData; \ const nsStyle##type_* parentdata_ = nullptr; \ RuleNodeCacheConditions conditions = aConditions; \ \ /* If |conditions.Cacheable()| might be true by the time we're done, we */ \ /* can't call parentContext->Style##type_() since it could recur into */ \ /* setting the same struct on the same rule node, causing a leak. */ \ if (aRuleDetail != eRuleFullReset && \ (!aStartStruct || (aRuleDetail != eRulePartialReset && \ aRuleDetail != eRuleNone))) { \ if (parentContext) { \ parentdata_ = parentContext->Style##type_(); \ } else { \ maybeFakeParentData.emplace(mPresContext); \ parentdata_ = maybeFakeParentData.ptr(); \ } \ } \ if (eStyleStruct_##type_ == eStyleStruct_Variables) \ /* no need to copy construct an nsStyleVariables, as we will copy */ \ /* inherited variables (and call SetUncacheable()) in */ \ /* ComputeVariablesData */ \ data_ = new (mPresContext) nsStyle##type_(mPresContext); \ else if (aStartStruct) \ /* We only need to compute the delta between this computed data and */ \ /* our computed data. */ \ data_ = new (mPresContext) \ nsStyle##type_(*static_cast<nsStyle##type_*>(aStartStruct)); \ else { \ if (aRuleDetail != eRuleFullMixed && aRuleDetail != eRuleFullReset) { \ /* No question. We will have to inherit. Go ahead and init */ \ /* with inherited vals from parent. */ \ conditions.SetUncacheable(); \ if (parentdata_) \ data_ = new (mPresContext) nsStyle##type_(*parentdata_); \ else \ data_ = new (mPresContext) nsStyle##type_(mPresContext); \ } \ else \ data_ = new (mPresContext) nsStyle##type_(mPresContext); \ } \ \ if (!parentdata_) \ parentdata_ = data_; /** * Begin an nsRuleNode::Compute*Data function for a reset struct. * * @param type_ The nsStyle* type this function computes. * @param data_ Variable (declared here) holding the result of this * function. * @param parentdata_ Variable (declared here) holding the parent style * context's data for this struct. */ #define COMPUTE_START_RESET(type_, data_, parentdata_) \ NS_ASSERTION(aRuleDetail != eRuleFullInherited, \ "should not have bothered calling Compute*Data"); \ \ nsStyleContext* parentContext = aContext->GetParent(); \ /* Reset structs don't inherit from first-line */ \ /* See similar code in WalkRuleTree */ \ while (parentContext && \ parentContext->GetPseudo() == nsCSSPseudoElements::firstLine) { \ parentContext = parentContext->GetParent(); \ } \ \ nsStyle##type_* data_; \ if (aStartStruct) \ /* We only need to compute the delta between this computed data and */ \ /* our computed data. */ \ data_ = new (mPresContext) \ nsStyle##type_(*static_cast<nsStyle##type_*>(aStartStruct)); \ else \ data_ = new (mPresContext) nsStyle##type_(mPresContext); \ \ /* If |conditions.Cacheable()| might be true by the time we're done, we */ \ /* can't call parentContext->Style##type_() since it could recur into */ \ /* setting the same struct on the same rule node, causing a leak. */ \ mozilla::Maybe<nsStyle##type_> maybeFakeParentData; \ const nsStyle##type_* parentdata_ = data_; \ if (aRuleDetail != eRuleFullReset && \ aRuleDetail != eRulePartialReset && \ aRuleDetail != eRuleNone) { \ if (parentContext) { \ parentdata_ = parentContext->Style##type_(); \ } else { \ maybeFakeParentData.emplace(mPresContext); \ parentdata_ = maybeFakeParentData.ptr(); \ } \ } \ RuleNodeCacheConditions conditions = aConditions; /** * End an nsRuleNode::Compute*Data function for an inherited struct. * * @param type_ The nsStyle* type this function computes. * @param data_ Variable holding the result of this function. */ #define COMPUTE_END_INHERITED(type_, data_) \ NS_POSTCONDITION(!conditions.CacheableWithoutDependencies() || \ aRuleDetail == eRuleFullReset || \ (aStartStruct && aRuleDetail == eRulePartialReset), \ "conditions.CacheableWithoutDependencies() must be false " \ "for inherited structs unless all properties have been " \ "specified with values other than inherit"); \ if (conditions.CacheableWithoutDependencies()) { \ /* We were fully specified and can therefore be cached right on the */ \ /* rule node. */ \ if (!aHighestNode->mStyleData.mInheritedData) { \ aHighestNode->mStyleData.mInheritedData = \ new (mPresContext) nsInheritedStyleData; \ } \ NS_ASSERTION(!aHighestNode->mStyleData.mInheritedData-> \ mStyleStructs[eStyleStruct_##type_], \ "Going to leak style data"); \ aHighestNode->mStyleData.mInheritedData-> \ mStyleStructs[eStyleStruct_##type_] = data_; \ /* Propagate the bit down. */ \ PropagateDependentBit(eStyleStruct_##type_, aHighestNode, data_); \ /* Tell the style context that it doesn't own the data */ \ aContext->AddStyleBit(NS_STYLE_INHERIT_BIT(type_)); \ } \ /* For inherited structs, our caller will cache the data on the */ \ /* style context */ \ \ return data_; /** * End an nsRuleNode::Compute*Data function for a reset struct. * * @param type_ The nsStyle* type this function computes. * @param data_ Variable holding the result of this function. */ #define COMPUTE_END_RESET(type_, data_) \ NS_POSTCONDITION(!conditions.CacheableWithoutDependencies() || \ aRuleDetail == eRuleNone || \ aRuleDetail == eRulePartialReset || \ aRuleDetail == eRuleFullReset, \ "conditions.CacheableWithoutDependencies() must be false " \ "for reset structs if any properties were specified as " \ "inherit"); \ if (conditions.CacheableWithoutDependencies()) { \ /* We were fully specified and can therefore be cached right on the */ \ /* rule node. */ \ if (!aHighestNode->mStyleData.mResetData) { \ aHighestNode->mStyleData.mResetData = \ new (mPresContext) nsConditionalResetStyleData; \ } \ NS_ASSERTION(!aHighestNode->mStyleData.mResetData-> \ GetStyleData(eStyleStruct_##type_), \ "Going to leak style data"); \ aHighestNode->mStyleData.mResetData-> \ SetStyleData(eStyleStruct_##type_, data_); \ /* Propagate the bit down. */ \ PropagateDependentBit(eStyleStruct_##type_, aHighestNode, data_); \ if (HasAnimationData()) { \ /* If we have animation data, the struct should be cached on the */ \ /* style context so that we can peek the struct. */ \ /* See comment in AnimValuesStyleRule::MapRuleInfoInto. */ \ StoreStyleOnContext(aContext, eStyleStruct_##type_, data_); \ } \ } else if (conditions.Cacheable()) { \ if (!mStyleData.mResetData) { \ mStyleData.mResetData = new (mPresContext) nsConditionalResetStyleData; \ } \ mStyleData.mResetData-> \ SetStyleData(eStyleStruct_##type_, mPresContext, data_, conditions); \ /* Tell the style context that it doesn't own the data */ \ aContext->AddStyleBit(NS_STYLE_INHERIT_BIT(type_)); \ aContext->SetStyle(eStyleStruct_##type_, data_); \ } else { \ /* We can't be cached in the rule node. We have to be put right */ \ /* on the style context. */ \ aContext->SetStyle(eStyleStruct_##type_, data_); \ if (aContext->GetParent()) { \ /* This is pessimistic; we could be uncacheable because we had a */ \ /* relative font-weight, for example, which does not need to defeat */ \ /* the restyle optimizations in RestyleManager.cpp that look at */ \ /* NS_STYLE_HAS_CHILD_THAT_USES_RESET_STYLE. */ \ aContext->GetParent()-> \ AddStyleBit(NS_STYLE_HAS_CHILD_THAT_USES_RESET_STYLE); \ } \ } \ \ return data_; // This function figures out how much scaling should be suppressed to // satisfy scriptminsize. This is our attempt to implement // http://www.w3.org/TR/MathML2/chapter3.html#id.3.3.4.2.2 // This is called after mScriptLevel, mScriptMinSize and mScriptSizeMultiplier // have been set in aFont. // // Here are the invariants we enforce: // 1) A decrease in size must not reduce the size below minscriptsize. // 2) An increase in size must not increase the size above the size we would // have if minscriptsize had not been applied anywhere. // 3) The scriptlevel-induced size change must between 1.0 and the parent's // scriptsizemultiplier^(new script level - old script level), as close to the // latter as possible subject to constraints 1 and 2. static nscoord ComputeScriptLevelSize(const nsStyleFont* aFont, const nsStyleFont* aParentFont, nsPresContext* aPresContext, nscoord* aUnconstrainedSize) { int32_t scriptLevelChange = aFont->mScriptLevel - aParentFont->mScriptLevel; if (scriptLevelChange == 0) { *aUnconstrainedSize = aParentFont->mScriptUnconstrainedSize; // Constraint #3 says that we cannot change size, and #1 and #2 are always // satisfied with no change. It's important this be fast because it covers // all non-MathML content. return aParentFont->mSize; } // Compute actual value of minScriptSize nscoord minScriptSize = aParentFont->mScriptMinSize; if (aFont->mAllowZoom) { minScriptSize = nsStyleFont::ZoomText(aPresContext, minScriptSize); } double scriptLevelScale = pow(aParentFont->mScriptSizeMultiplier, scriptLevelChange); // Compute the size we would have had if minscriptsize had never been // applied, also prevent overflow (bug 413274) *aUnconstrainedSize = NSToCoordRoundWithClamp(aParentFont->mScriptUnconstrainedSize*scriptLevelScale); // Compute the size we could get via scriptlevel change nscoord scriptLevelSize = NSToCoordRoundWithClamp(aParentFont->mSize*scriptLevelScale); if (scriptLevelScale <= 1.0) { if (aParentFont->mSize <= minScriptSize) { // We can't decrease the font size at all, so just stick to no change // (authors are allowed to explicitly set the font size smaller than // minscriptsize) return aParentFont->mSize; } // We can decrease, so apply constraint #1 return std::max(minScriptSize, scriptLevelSize); } else { // scriptminsize can only make sizes larger than the unconstrained size NS_ASSERTION(*aUnconstrainedSize <= scriptLevelSize, "How can this ever happen?"); // Apply constraint #2 return std::min(scriptLevelSize, std::max(*aUnconstrainedSize, minScriptSize)); } } /* static */ nscoord nsRuleNode::CalcFontPointSize(int32_t aHTMLSize, int32_t aBasePointSize, nsPresContext* aPresContext, nsFontSizeType aFontSizeType) { #define sFontSizeTableMin 9 #define sFontSizeTableMax 16 // This table seems to be the one used by MacIE5. We hope its adoption in Mozilla // and eventually in WinIE5.5 will help to establish a standard rendering across // platforms and browsers. For now, it is used only in Strict mode. More can be read // in the document written by Todd Farhner at: // http://style.verso.com/font_size_intervals/altintervals.html // static int32_t sStrictFontSizeTable[sFontSizeTableMax - sFontSizeTableMin + 1][8] = { { 9, 9, 9, 9, 11, 14, 18, 27}, { 9, 9, 9, 10, 12, 15, 20, 30}, { 9, 9, 10, 11, 13, 17, 22, 33}, { 9, 9, 10, 12, 14, 18, 24, 36}, { 9, 10, 12, 13, 16, 20, 26, 39}, { 9, 10, 12, 14, 17, 21, 28, 42}, { 9, 10, 13, 15, 18, 23, 30, 45}, { 9, 10, 13, 16, 18, 24, 32, 48} }; // HTML 1 2 3 4 5 6 7 // CSS xxs xs s m l xl xxl // | // user pref // //------------------------------------------------------------ // // This table gives us compatibility with WinNav4 for the default fonts only. // In WinNav4, the default fonts were: // // Times/12pt == Times/16px at 96ppi // Courier/10pt == Courier/13px at 96ppi // // The 2 lines below marked "anchored" have the exact pixel sizes used by // WinNav4 for Times/12pt and Courier/10pt at 96ppi. As you can see, the // HTML size 3 (user pref) for those 2 anchored lines is 13px and 16px. // // All values other than the anchored values were filled in by hand, never // going below 9px, and maintaining a "diagonal" relationship. See for // example the 13s -- they follow a diagonal line through the table. // static int32_t sQuirksFontSizeTable[sFontSizeTableMax - sFontSizeTableMin + 1][8] = { { 9, 9, 9, 9, 11, 14, 18, 28 }, { 9, 9, 9, 10, 12, 15, 20, 31 }, { 9, 9, 9, 11, 13, 17, 22, 34 }, { 9, 9, 10, 12, 14, 18, 24, 37 }, { 9, 9, 10, 13, 16, 20, 26, 40 }, // anchored (13) { 9, 9, 11, 14, 17, 21, 28, 42 }, { 9, 10, 12, 15, 17, 23, 30, 45 }, { 9, 10, 13, 16, 18, 24, 32, 48 } // anchored (16) }; // HTML 1 2 3 4 5 6 7 // CSS xxs xs s m l xl xxl // | // user pref #if 0 // // These are the exact pixel values used by WinIE5 at 96ppi. // { ?, 8, 11, 12, 13, 16, 21, 32 }, // smallest { ?, 9, 12, 13, 16, 21, 27, 40 }, // smaller { ?, 10, 13, 16, 18, 24, 32, 48 }, // medium { ?, 13, 16, 19, 21, 27, 37, ?? }, // larger { ?, 16, 19, 21, 24, 32, 43, ?? } // largest // // HTML 1 2 3 4 5 6 7 // CSS ? ? ? ? ? ? ? ? // // (CSS not tested yet.) // #endif static int32_t sFontSizeFactors[8] = { 60,75,89,100,120,150,200,300 }; static int32_t sCSSColumns[7] = {0, 1, 2, 3, 4, 5, 6}; // xxs...xxl static int32_t sHTMLColumns[7] = {1, 2, 3, 4, 5, 6, 7}; // 1...7 double dFontSize; if (aFontSizeType == eFontSize_HTML) { aHTMLSize--; // input as 1-7 } if (aHTMLSize < 0) aHTMLSize = 0; else if (aHTMLSize > 6) aHTMLSize = 6; int32_t* column; switch (aFontSizeType) { case eFontSize_HTML: column = sHTMLColumns; break; case eFontSize_CSS: column = sCSSColumns; break; } // Make special call specifically for fonts (needed PrintPreview) int32_t fontSize = nsPresContext::AppUnitsToIntCSSPixels(aBasePointSize); if ((fontSize >= sFontSizeTableMin) && (fontSize <= sFontSizeTableMax)) { int32_t row = fontSize - sFontSizeTableMin; if (aPresContext->CompatibilityMode() == eCompatibility_NavQuirks) { dFontSize = nsPresContext::CSSPixelsToAppUnits(sQuirksFontSizeTable[row][column[aHTMLSize]]); } else { dFontSize = nsPresContext::CSSPixelsToAppUnits(sStrictFontSizeTable[row][column[aHTMLSize]]); } } else { int32_t factor = sFontSizeFactors[column[aHTMLSize]]; dFontSize = (factor * aBasePointSize) / 100; } if (1.0 < dFontSize) { return (nscoord)dFontSize; } return (nscoord)1; } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ /* static */ nscoord nsRuleNode::FindNextSmallerFontSize(nscoord aFontSize, int32_t aBasePointSize, nsPresContext* aPresContext, nsFontSizeType aFontSizeType) { int32_t index; int32_t indexMin; int32_t indexMax; float relativePosition; nscoord smallerSize; nscoord indexFontSize = aFontSize; // XXX initialize to quell a spurious gcc3.2 warning nscoord smallestIndexFontSize; nscoord largestIndexFontSize; nscoord smallerIndexFontSize; nscoord largerIndexFontSize; nscoord onePx = nsPresContext::CSSPixelsToAppUnits(1); if (aFontSizeType == eFontSize_HTML) { indexMin = 1; indexMax = 7; } else { indexMin = 0; indexMax = 6; } smallestIndexFontSize = CalcFontPointSize(indexMin, aBasePointSize, aPresContext, aFontSizeType); largestIndexFontSize = CalcFontPointSize(indexMax, aBasePointSize, aPresContext, aFontSizeType); if (aFontSize > smallestIndexFontSize) { if (aFontSize < NSToCoordRound(float(largestIndexFontSize) * 1.5)) { // smaller will be in HTML table // find largest index smaller than current for (index = indexMax; index >= indexMin; index--) { indexFontSize = CalcFontPointSize(index, aBasePointSize, aPresContext, aFontSizeType); if (indexFontSize < aFontSize) break; } // set up points beyond table for interpolation purposes if (indexFontSize == smallestIndexFontSize) { smallerIndexFontSize = indexFontSize - onePx; largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType); } else if (indexFontSize == largestIndexFontSize) { smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType); largerIndexFontSize = NSToCoordRound(float(largestIndexFontSize) * 1.5); } else { smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType); largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType); } // compute the relative position of the parent size between the two closest indexed sizes relativePosition = float(aFontSize - indexFontSize) / float(largerIndexFontSize - indexFontSize); // set the new size to have the same relative position between the next smallest two indexed sizes smallerSize = smallerIndexFontSize + NSToCoordRound(relativePosition * (indexFontSize - smallerIndexFontSize)); } else { // larger than HTML table, drop by 33% smallerSize = NSToCoordRound(float(aFontSize) / 1.5); } } else { // smaller than HTML table, drop by 1px smallerSize = std::max(aFontSize - onePx, onePx); } return smallerSize; } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ /* static */ nscoord nsRuleNode::FindNextLargerFontSize(nscoord aFontSize, int32_t aBasePointSize, nsPresContext* aPresContext, nsFontSizeType aFontSizeType) { int32_t index; int32_t indexMin; int32_t indexMax; float relativePosition; nscoord adjustment; nscoord largerSize; nscoord indexFontSize = aFontSize; // XXX initialize to quell a spurious gcc3.2 warning nscoord smallestIndexFontSize; nscoord largestIndexFontSize; nscoord smallerIndexFontSize; nscoord largerIndexFontSize; nscoord onePx = nsPresContext::CSSPixelsToAppUnits(1); if (aFontSizeType == eFontSize_HTML) { indexMin = 1; indexMax = 7; } else { indexMin = 0; indexMax = 6; } smallestIndexFontSize = CalcFontPointSize(indexMin, aBasePointSize, aPresContext, aFontSizeType); largestIndexFontSize = CalcFontPointSize(indexMax, aBasePointSize, aPresContext, aFontSizeType); if (aFontSize > (smallestIndexFontSize - onePx)) { if (aFontSize < largestIndexFontSize) { // larger will be in HTML table // find smallest index larger than current for (index = indexMin; index <= indexMax; index++) { indexFontSize = CalcFontPointSize(index, aBasePointSize, aPresContext, aFontSizeType); if (indexFontSize > aFontSize) break; } // set up points beyond table for interpolation purposes if (indexFontSize == smallestIndexFontSize) { smallerIndexFontSize = indexFontSize - onePx; largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType); } else if (indexFontSize == largestIndexFontSize) { smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType); largerIndexFontSize = NSCoordSaturatingMultiply(largestIndexFontSize, 1.5); } else { smallerIndexFontSize = CalcFontPointSize(index-1, aBasePointSize, aPresContext, aFontSizeType); largerIndexFontSize = CalcFontPointSize(index+1, aBasePointSize, aPresContext, aFontSizeType); } // compute the relative position of the parent size between the two closest indexed sizes relativePosition = float(aFontSize - smallerIndexFontSize) / float(indexFontSize - smallerIndexFontSize); // set the new size to have the same relative position between the next largest two indexed sizes adjustment = NSCoordSaturatingNonnegativeMultiply(largerIndexFontSize - indexFontSize, relativePosition); largerSize = NSCoordSaturatingAdd(indexFontSize, adjustment); } else { // larger than HTML table, increase by 50% largerSize = NSCoordSaturatingMultiply(aFontSize, 1.5); } } else { // smaller than HTML table, increase by 1px largerSize = NSCoordSaturatingAdd(aFontSize, onePx); } return largerSize; } struct SetFontSizeCalcOps : public css::BasicCoordCalcOps, public css::NumbersAlreadyNormalizedOps { // The parameters beyond aValue that we need for CalcLengthWith. const nscoord mParentSize; const nsStyleFont* const mParentFont; nsPresContext* const mPresContext; nsStyleContext* const mStyleContext; const bool mAtRoot; RuleNodeCacheConditions& mConditions; SetFontSizeCalcOps(nscoord aParentSize, const nsStyleFont* aParentFont, nsPresContext* aPresContext, nsStyleContext* aStyleContext, bool aAtRoot, RuleNodeCacheConditions& aConditions) : mParentSize(aParentSize), mParentFont(aParentFont), mPresContext(aPresContext), mStyleContext(aStyleContext), mAtRoot(aAtRoot), mConditions(aConditions) { } result_type ComputeLeafValue(const nsCSSValue& aValue) { nscoord size; if (aValue.IsLengthUnit()) { // Note that font-based length units use the parent's size // unadjusted for scriptlevel changes. A scriptlevel change // between us and the parent is simply ignored. size = CalcLengthWith(aValue, mParentSize, mParentFont, mStyleContext, mPresContext, mAtRoot, true, mConditions); if (!aValue.IsRelativeLengthUnit() && mParentFont->mAllowZoom) { size = nsStyleFont::ZoomText(mPresContext, size); } } else if (eCSSUnit_Percent == aValue.GetUnit()) { mConditions.SetUncacheable(); // Note that % units use the parent's size unadjusted for scriptlevel // changes. A scriptlevel change between us and the parent is simply // ignored. // aValue.GetPercentValue() may be negative for, e.g., calc(-50%) size = NSCoordSaturatingMultiply(mParentSize, aValue.GetPercentValue()); } else { MOZ_ASSERT(false, "unexpected value"); size = mParentSize; } return size; } }; /* static */ void nsRuleNode::SetFontSize(nsPresContext* aPresContext, nsStyleContext* aContext, const nsRuleData* aRuleData, const nsStyleFont* aFont, const nsStyleFont* aParentFont, nscoord* aSize, const nsFont& aSystemFont, nscoord aParentSize, nscoord aScriptLevelAdjustedParentSize, bool aUsedStartStruct, bool aAtRoot, RuleNodeCacheConditions& aConditions) { // If false, means that *aSize has not been zoomed. If true, means that // *aSize has been zoomed iff aParentFont->mAllowZoom is true. bool sizeIsZoomedAccordingToParent = false; int32_t baseSize = (int32_t) aPresContext-> GetDefaultFont(aFont->mGenericID, aFont->mLanguage)->size; const nsCSSValue* sizeValue = aRuleData->ValueForFontSize(); if (eCSSUnit_Enumerated == sizeValue->GetUnit()) { int32_t value = sizeValue->GetIntValue(); if ((NS_STYLE_FONT_SIZE_XXSMALL <= value) && (value <= NS_STYLE_FONT_SIZE_XXLARGE)) { *aSize = CalcFontPointSize(value, baseSize, aPresContext, eFontSize_CSS); } else if (NS_STYLE_FONT_SIZE_XXXLARGE == value) { // <font size="7"> is not specified in CSS, so we don't use eFontSize_CSS. *aSize = CalcFontPointSize(value, baseSize, aPresContext); } else if (NS_STYLE_FONT_SIZE_LARGER == value || NS_STYLE_FONT_SIZE_SMALLER == value) { aConditions.SetUncacheable(); // Un-zoom so we use the tables correctly. We'll then rezoom due // to the |zoom = true| above. // Note that relative units here use the parent's size unadjusted // for scriptlevel changes. A scriptlevel change between us and the parent // is simply ignored. nscoord parentSize = aParentSize; if (aParentFont->mAllowZoom) { parentSize = nsStyleFont::UnZoomText(aPresContext, parentSize); } if (NS_STYLE_FONT_SIZE_LARGER == value) { *aSize = FindNextLargerFontSize(parentSize, baseSize, aPresContext, eFontSize_CSS); NS_ASSERTION(*aSize >= parentSize, "FindNextLargerFontSize failed"); } else { *aSize = FindNextSmallerFontSize(parentSize, baseSize, aPresContext, eFontSize_CSS); NS_ASSERTION(*aSize < parentSize || parentSize <= nsPresContext::CSSPixelsToAppUnits(1), "FindNextSmallerFontSize failed"); } } else { NS_NOTREACHED("unexpected value"); } } else if (sizeValue->IsLengthUnit() || sizeValue->GetUnit() == eCSSUnit_Percent || sizeValue->IsCalcUnit()) { SetFontSizeCalcOps ops(aParentSize, aParentFont, aPresContext, aContext, aAtRoot, aConditions); *aSize = css::ComputeCalc(*sizeValue, ops); if (*aSize < 0) { MOZ_ASSERT(sizeValue->IsCalcUnit(), "negative lengths and percents should be rejected by parser"); *aSize = 0; } // The calc ops will always zoom its result according to the value // of aParentFont->mAllowZoom. sizeIsZoomedAccordingToParent = true; } else if (eCSSUnit_System_Font == sizeValue->GetUnit()) { // this becomes our cascading size *aSize = aSystemFont.size; } else if (eCSSUnit_Inherit == sizeValue->GetUnit() || eCSSUnit_Unset == sizeValue->GetUnit()) { aConditions.SetUncacheable(); // We apply scriptlevel change for this case, because the default is // to inherit and we don't want explicit "inherit" to differ from the // default. *aSize = aScriptLevelAdjustedParentSize; sizeIsZoomedAccordingToParent = true; } else if (eCSSUnit_Initial == sizeValue->GetUnit()) { // The initial value is 'medium', which has magical sizing based on // the generic font family, so do that here too. *aSize = baseSize; } else { NS_ASSERTION(eCSSUnit_Null == sizeValue->GetUnit(), "What kind of font-size value is this?"); // if aUsedStartStruct is true, then every single property in the // font struct is being set all at once. This means scriptlevel is not // going to have any influence on the font size; there is no need to // do anything here. if (!aUsedStartStruct && aParentSize != aScriptLevelAdjustedParentSize) { // There was no rule affecting the size but the size has been // affected by the parent's size via scriptlevel change. So we cannot // store the data in the rule tree. aConditions.SetUncacheable(); *aSize = aScriptLevelAdjustedParentSize; sizeIsZoomedAccordingToParent = true; } else { return; } } // We want to zoom the cascaded size so that em-based measurements, // line-heights, etc., work. bool currentlyZoomed = sizeIsZoomedAccordingToParent && aParentFont->mAllowZoom; if (!currentlyZoomed && aFont->mAllowZoom) { *aSize = nsStyleFont::ZoomText(aPresContext, *aSize); } else if (currentlyZoomed && !aFont->mAllowZoom) { *aSize = nsStyleFont::UnZoomText(aPresContext, *aSize); } } static int8_t ClampTo8Bit(int32_t aValue) { if (aValue < -128) return -128; if (aValue > 127) return 127; return int8_t(aValue); } /* static */ void nsRuleNode::SetFont(nsPresContext* aPresContext, nsStyleContext* aContext, uint8_t aGenericFontID, const nsRuleData* aRuleData, const nsStyleFont* aParentFont, nsStyleFont* aFont, bool aUsedStartStruct, RuleNodeCacheConditions& aConditions) { bool atRoot = !aContext->GetParent(); // -x-text-zoom: none, inherit, initial bool allowZoom; const nsCSSValue* textZoomValue = aRuleData->ValueForTextZoom(); if (eCSSUnit_Null != textZoomValue->GetUnit()) { if (eCSSUnit_Inherit == textZoomValue->GetUnit()) { allowZoom = aParentFont->mAllowZoom; } else if (eCSSUnit_None == textZoomValue->GetUnit()) { allowZoom = false; } else { MOZ_ASSERT(eCSSUnit_Initial == textZoomValue->GetUnit(), "unexpected unit"); allowZoom = true; } aFont->EnableZoom(aPresContext, allowZoom); } // mLanguage must be set before before any of the CalcLengthWith calls // (direct calls or calls via SetFontSize) for the cases where |aParentFont| // is the same as |aFont|. // // -x-lang: string, inherit // This is not a real CSS property, it is an HTML attribute mapped to CSS. const nsCSSValue* langValue = aRuleData->ValueForLang(); if (eCSSUnit_Ident == langValue->GetUnit()) { nsAutoString lang; langValue->GetStringValue(lang); nsContentUtils::ASCIIToLower(lang); aFont->mLanguage = NS_Atomize(lang); aFont->mExplicitLanguage = true; } const nsFont* defaultVariableFont = aPresContext->GetDefaultFont(kPresContext_DefaultVariableFont_ID, aFont->mLanguage); // -moz-system-font: enum (never inherit!) static_assert( NS_STYLE_FONT_CAPTION == LookAndFeel::eFont_Caption && NS_STYLE_FONT_ICON == LookAndFeel::eFont_Icon && NS_STYLE_FONT_MENU == LookAndFeel::eFont_Menu && NS_STYLE_FONT_MESSAGE_BOX == LookAndFeel::eFont_MessageBox && NS_STYLE_FONT_SMALL_CAPTION == LookAndFeel::eFont_SmallCaption && NS_STYLE_FONT_STATUS_BAR == LookAndFeel::eFont_StatusBar && NS_STYLE_FONT_WINDOW == LookAndFeel::eFont_Window && NS_STYLE_FONT_DOCUMENT == LookAndFeel::eFont_Document && NS_STYLE_FONT_WORKSPACE == LookAndFeel::eFont_Workspace && NS_STYLE_FONT_DESKTOP == LookAndFeel::eFont_Desktop && NS_STYLE_FONT_INFO == LookAndFeel::eFont_Info && NS_STYLE_FONT_DIALOG == LookAndFeel::eFont_Dialog && NS_STYLE_FONT_BUTTON == LookAndFeel::eFont_Button && NS_STYLE_FONT_PULL_DOWN_MENU == LookAndFeel::eFont_PullDownMenu && NS_STYLE_FONT_LIST == LookAndFeel::eFont_List && NS_STYLE_FONT_FIELD == LookAndFeel::eFont_Field, "LookAndFeel.h system-font constants out of sync with nsStyleConsts.h"); // Fall back to defaultVariableFont. nsFont systemFont = *defaultVariableFont; const nsCSSValue* systemFontValue = aRuleData->ValueForSystemFont(); if (eCSSUnit_Enumerated == systemFontValue->GetUnit()) { gfxFontStyle fontStyle; LookAndFeel::FontID fontID = (LookAndFeel::FontID)systemFontValue->GetIntValue(); float devPerCSS = (float)nsPresContext::AppUnitsPerCSSPixel() / aPresContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom(); nsAutoString systemFontName; if (LookAndFeel::GetFont(fontID, systemFontName, fontStyle, devPerCSS)) { systemFontName.Trim("\"'"); systemFont.fontlist = FontFamilyList(systemFontName, eUnquotedName); systemFont.fontlist.SetDefaultFontType(eFamily_none); systemFont.style = fontStyle.style; systemFont.systemFont = fontStyle.systemFont; systemFont.weight = fontStyle.weight; systemFont.stretch = fontStyle.stretch; systemFont.size = NSFloatPixelsToAppUnits(fontStyle.size, aPresContext->DeviceContext()-> AppUnitsPerDevPixelAtUnitFullZoom()); //systemFont.langGroup = fontStyle.langGroup; systemFont.sizeAdjust = fontStyle.sizeAdjust; #ifdef XP_WIN // XXXldb This platform-specific stuff should be in the // LookAndFeel implementation, not here. // XXXzw Should we even still *have* this code? It looks to be making // old, probably obsolete assumptions. if (fontID == LookAndFeel::eFont_Field || fontID == LookAndFeel::eFont_Button || fontID == LookAndFeel::eFont_List) { // As far as I can tell the system default fonts and sizes // on MS-Windows for Buttons, Listboxes/Comboxes and Text Fields are // all pre-determined and cannot be changed by either the control panel // or programmatically. // Fields (text fields) // Button and Selects (listboxes/comboboxes) // We use whatever font is defined by the system. Which it appears // (and the assumption is) it is always a proportional font. Then we // always use 2 points smaller than what the browser has defined as // the default proportional font. // Assumption: system defined font is proportional systemFont.size = std::max(defaultVariableFont->size - nsPresContext::CSSPointsToAppUnits(2), 0); } #endif } } // font-family: font family list, enum, inherit const nsCSSValue* familyValue = aRuleData->ValueForFontFamily(); NS_ASSERTION(eCSSUnit_Enumerated != familyValue->GetUnit(), "system fonts should not be in mFamily anymore"); if (eCSSUnit_FontFamilyList == familyValue->GetUnit()) { // set the correct font if we are using DocumentFonts OR we are overriding for XUL // MJA: bug 31816 bool useDocumentFonts = aPresContext->GetCachedBoolPref(kPresContext_UseDocumentFonts); if (aGenericFontID == kGenericFont_NONE || (!useDocumentFonts && (aGenericFontID == kGenericFont_cursive || aGenericFontID == kGenericFont_fantasy))) { FontFamilyType defaultGeneric = defaultVariableFont->fontlist.FirstGeneric(); MOZ_ASSERT(defaultVariableFont->fontlist.Length() == 1 && (defaultGeneric == eFamily_serif || defaultGeneric == eFamily_sans_serif)); if (defaultGeneric != eFamily_none) { if (useDocumentFonts) { aFont->mFont.fontlist.SetDefaultFontType(defaultGeneric); } else { // Either prioritize the first generic in the list, // or (if there isn't one) prepend the default variable font. if (!aFont->mFont.fontlist.PrioritizeFirstGeneric()) { aFont->mFont.fontlist.PrependGeneric(defaultGeneric); } } } } else { aFont->mFont.fontlist.SetDefaultFontType(eFamily_none); } aFont->mFont.systemFont = false; // Technically this is redundant with the code below, but it's good // to have since we'll still want it once we get rid of // SetGenericFont (bug 380915). aFont->mGenericID = aGenericFontID; } else if (eCSSUnit_System_Font == familyValue->GetUnit()) { aFont->mFont.fontlist = systemFont.fontlist; aFont->mFont.systemFont = true; aFont->mGenericID = kGenericFont_NONE; } else if (eCSSUnit_Inherit == familyValue->GetUnit() || eCSSUnit_Unset == familyValue->GetUnit()) { aConditions.SetUncacheable(); aFont->mFont.fontlist = aParentFont->mFont.fontlist; aFont->mFont.systemFont = aParentFont->mFont.systemFont; aFont->mGenericID = aParentFont->mGenericID; } else if (eCSSUnit_Initial == familyValue->GetUnit()) { aFont->mFont.fontlist = defaultVariableFont->fontlist; aFont->mFont.systemFont = defaultVariableFont->systemFont; aFont->mGenericID = kGenericFont_NONE; } // When we're in the loop in SetGenericFont, we must ensure that we // always keep aFont->mFlags set to the correct generic. But we have // to be careful not to touch it when we're called directly from // ComputeFontData, because we could have a start struct. if (aGenericFontID != kGenericFont_NONE) { aFont->mGenericID = aGenericFontID; } // -moz-math-variant: enum, inherit, initial SetValue(*aRuleData->ValueForMathVariant(), aFont->mMathVariant, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mMathVariant, NS_MATHML_MATHVARIANT_NONE); // -moz-math-display: enum, inherit, initial SetValue(*aRuleData->ValueForMathDisplay(), aFont->mMathDisplay, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mMathDisplay, NS_MATHML_DISPLAYSTYLE_INLINE); // font-smoothing: enum, inherit, initial SetValue(*aRuleData->ValueForOsxFontSmoothing(), aFont->mFont.smoothing, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.smoothing, defaultVariableFont->smoothing); // font-style: enum, inherit, initial, -moz-system-font if (aFont->mMathVariant != NS_MATHML_MATHVARIANT_NONE) { // -moz-math-variant overrides font-style aFont->mFont.style = NS_FONT_STYLE_NORMAL; } else { SetValue(*aRuleData->ValueForFontStyle(), aFont->mFont.style, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.style, defaultVariableFont->style, Unused, Unused, Unused, systemFont.style); } // font-weight: int, enum, inherit, initial, -moz-system-font // special handling for enum const nsCSSValue* weightValue = aRuleData->ValueForFontWeight(); if (aFont->mMathVariant != NS_MATHML_MATHVARIANT_NONE) { // -moz-math-variant overrides font-weight aFont->mFont.weight = NS_FONT_WEIGHT_NORMAL; } else if (eCSSUnit_Enumerated == weightValue->GetUnit()) { int32_t value = weightValue->GetIntValue(); switch (value) { case NS_STYLE_FONT_WEIGHT_NORMAL: case NS_STYLE_FONT_WEIGHT_BOLD: aFont->mFont.weight = value; break; case NS_STYLE_FONT_WEIGHT_BOLDER: { aConditions.SetUncacheable(); int32_t inheritedValue = aParentFont->mFont.weight; if (inheritedValue <= 300) { aFont->mFont.weight = 400; } else if (inheritedValue <= 500) { aFont->mFont.weight = 700; } else { aFont->mFont.weight = 900; } break; } case NS_STYLE_FONT_WEIGHT_LIGHTER: { aConditions.SetUncacheable(); int32_t inheritedValue = aParentFont->mFont.weight; if (inheritedValue < 600) { aFont->mFont.weight = 100; } else if (inheritedValue < 800) { aFont->mFont.weight = 400; } else { aFont->mFont.weight = 700; } break; } } } else SetValue(*weightValue, aFont->mFont.weight, aConditions, SETVAL_INTEGER | SETVAL_UNSET_INHERIT, aParentFont->mFont.weight, defaultVariableFont->weight, Unused, Unused, Unused, systemFont.weight); // font-stretch: enum, inherit, initial, -moz-system-font SetValue(*aRuleData->ValueForFontStretch(), aFont->mFont.stretch, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.stretch, defaultVariableFont->stretch, Unused, Unused, Unused, systemFont.stretch); // Compute scriptlevel, scriptminsize and scriptsizemultiplier now so // they're available for font-size computation. // -moz-script-min-size: length const nsCSSValue* scriptMinSizeValue = aRuleData->ValueForScriptMinSize(); if (scriptMinSizeValue->IsLengthUnit()) { // scriptminsize in font units (em, ex) has to be interpreted relative // to the parent font, or the size definitions are circular and we // aFont->mScriptMinSize = CalcLengthWith(*scriptMinSizeValue, aParentFont->mSize, aParentFont, aContext, aPresContext, atRoot, true /* aUseUserFontSet */, aConditions); } // -moz-script-size-multiplier: factor, inherit, initial SetFactor(*aRuleData->ValueForScriptSizeMultiplier(), aFont->mScriptSizeMultiplier, aConditions, aParentFont->mScriptSizeMultiplier, NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER, SETFCT_POSITIVE | SETFCT_UNSET_INHERIT); // -moz-script-level: integer, number, inherit const nsCSSValue* scriptLevelValue = aRuleData->ValueForScriptLevel(); if (eCSSUnit_Integer == scriptLevelValue->GetUnit()) { // "relative" aConditions.SetUncacheable(); aFont->mScriptLevel = ClampTo8Bit(aParentFont->mScriptLevel + scriptLevelValue->GetIntValue()); } else if (eCSSUnit_Number == scriptLevelValue->GetUnit()) { // "absolute" aFont->mScriptLevel = ClampTo8Bit(int32_t(scriptLevelValue->GetFloatValue())); } else if (eCSSUnit_Auto == scriptLevelValue->GetUnit()) { // auto aConditions.SetUncacheable(); aFont->mScriptLevel = ClampTo8Bit(aParentFont->mScriptLevel + (aParentFont->mMathDisplay == NS_MATHML_DISPLAYSTYLE_INLINE ? 1 : 0)); } else if (eCSSUnit_Inherit == scriptLevelValue->GetUnit() || eCSSUnit_Unset == scriptLevelValue->GetUnit()) { aConditions.SetUncacheable(); aFont->mScriptLevel = aParentFont->mScriptLevel; } else if (eCSSUnit_Initial == scriptLevelValue->GetUnit()) { aFont->mScriptLevel = 0; } // font-kerning: none, enum, inherit, initial, -moz-system-font SetValue(*aRuleData->ValueForFontKerning(), aFont->mFont.kerning, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.kerning, defaultVariableFont->kerning, Unused, Unused, Unused, systemFont.kerning); // font-synthesis: none, enum (bit field), inherit, initial, -moz-system-font SetValue(*aRuleData->ValueForFontSynthesis(), aFont->mFont.synthesis, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.synthesis, defaultVariableFont->synthesis, Unused, /* none */ 0, Unused, systemFont.synthesis); // font-variant-alternates: normal, enum (bit field) + functions, inherit, // initial, -moz-system-font const nsCSSValue* variantAlternatesValue = aRuleData->ValueForFontVariantAlternates(); int32_t variantAlternates = 0; switch (variantAlternatesValue->GetUnit()) { case eCSSUnit_Inherit: case eCSSUnit_Unset: aFont->mFont.CopyAlternates(aParentFont->mFont); aConditions.SetUncacheable(); break; case eCSSUnit_Initial: case eCSSUnit_Normal: aFont->mFont.variantAlternates = 0; aFont->mFont.alternateValues.Clear(); aFont->mFont.featureValueLookup = nullptr; break; case eCSSUnit_Pair: NS_ASSERTION(variantAlternatesValue->GetPairValue().mXValue.GetUnit() == eCSSUnit_Enumerated, "strange unit for variantAlternates"); variantAlternates = variantAlternatesValue->GetPairValue().mXValue.GetIntValue(); aFont->mFont.variantAlternates = variantAlternates; if (variantAlternates & NS_FONT_VARIANT_ALTERNATES_FUNCTIONAL_MASK) { // fetch the feature lookup object from the styleset MOZ_ASSERT(aPresContext->StyleSet()->IsGecko(), "ServoStyleSets should not have rule nodes"); aFont->mFont.featureValueLookup = aPresContext->StyleSet()->AsGecko()->GetFontFeatureValuesLookup(); NS_ASSERTION(variantAlternatesValue->GetPairValue().mYValue.GetUnit() == eCSSUnit_List, "function list not a list value"); nsStyleUtil::ComputeFunctionalAlternates( variantAlternatesValue->GetPairValue().mYValue.GetListValue(), aFont->mFont.alternateValues); } break; default: break; } // font-variant-caps: normal, enum, inherit, initial, -moz-system-font SetValue(*aRuleData->ValueForFontVariantCaps(), aFont->mFont.variantCaps, aConditions, SETVAL_ENUMERATED |SETVAL_UNSET_INHERIT, aParentFont->mFont.variantCaps, defaultVariableFont->variantCaps, Unused, Unused, /* normal */ 0, systemFont.variantCaps); // font-variant-east-asian: normal, enum (bit field), inherit, initial, // -moz-system-font SetValue(*aRuleData->ValueForFontVariantEastAsian(), aFont->mFont.variantEastAsian, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.variantEastAsian, defaultVariableFont->variantEastAsian, Unused, Unused, /* normal */ 0, systemFont.variantEastAsian); // font-variant-ligatures: normal, none, enum (bit field), inherit, initial, // -moz-system-font SetValue(*aRuleData->ValueForFontVariantLigatures(), aFont->mFont.variantLigatures, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.variantLigatures, defaultVariableFont->variantLigatures, Unused, NS_FONT_VARIANT_LIGATURES_NONE, /* normal */ 0, systemFont.variantLigatures); // font-variant-numeric: normal, enum (bit field), inherit, initial, // -moz-system-font SetValue(*aRuleData->ValueForFontVariantNumeric(), aFont->mFont.variantNumeric, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.variantNumeric, defaultVariableFont->variantNumeric, Unused, Unused, /* normal */ 0, systemFont.variantNumeric); // font-variant-position: normal, enum, inherit, initial, // -moz-system-font SetValue(*aRuleData->ValueForFontVariantPosition(), aFont->mFont.variantPosition, aConditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, aParentFont->mFont.variantPosition, defaultVariableFont->variantPosition, Unused, Unused, /* normal */ 0, systemFont.variantPosition); // font-feature-settings const nsCSSValue* featureSettingsValue = aRuleData->ValueForFontFeatureSettings(); switch (featureSettingsValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Normal: case eCSSUnit_Initial: aFont->mFont.fontFeatureSettings.Clear(); break; case eCSSUnit_Inherit: case eCSSUnit_Unset: aConditions.SetUncacheable(); aFont->mFont.fontFeatureSettings = aParentFont->mFont.fontFeatureSettings; break; case eCSSUnit_System_Font: aFont->mFont.fontFeatureSettings = systemFont.fontFeatureSettings; break; case eCSSUnit_PairList: case eCSSUnit_PairListDep: ComputeFontFeatures(featureSettingsValue->GetPairListValue(), aFont->mFont.fontFeatureSettings); break; default: MOZ_ASSERT(false, "unexpected value unit"); break; } // font-language-override const nsCSSValue* languageOverrideValue = aRuleData->ValueForFontLanguageOverride(); if (eCSSUnit_Inherit == languageOverrideValue->GetUnit() || eCSSUnit_Unset == languageOverrideValue->GetUnit()) { aConditions.SetUncacheable(); aFont->mFont.languageOverride = aParentFont->mFont.languageOverride; } else if (eCSSUnit_Normal == languageOverrideValue->GetUnit() || eCSSUnit_Initial == languageOverrideValue->GetUnit()) { aFont->mFont.languageOverride.Truncate(); } else if (eCSSUnit_System_Font == languageOverrideValue->GetUnit()) { aFont->mFont.languageOverride = systemFont.languageOverride; } else if (eCSSUnit_String == languageOverrideValue->GetUnit()) { languageOverrideValue->GetStringValue(aFont->mFont.languageOverride); } // -moz-min-font-size-ratio: percent, inherit const nsCSSValue* minFontSizeRatio = aRuleData->ValueForMinFontSizeRatio(); switch (minFontSizeRatio->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Unset: case eCSSUnit_Inherit: aFont->mMinFontSizeRatio = aParentFont->mMinFontSizeRatio; aConditions.SetUncacheable(); break; case eCSSUnit_Initial: aFont->mMinFontSizeRatio = 100; // 100% break; case eCSSUnit_Percent: { // While percentages are parsed as floating point numbers, we // only store an integer in the range [0, 255] since that's all // we need for now. float percent = minFontSizeRatio->GetPercentValue() * 100; if (percent < 0) { percent = 0; } else if (percent > 255) { percent = 255; } aFont->mMinFontSizeRatio = uint8_t(percent); break; } default: MOZ_ASSERT_UNREACHABLE("Unknown unit for -moz-min-font-size-ratio"); } nscoord scriptLevelAdjustedUnconstrainedParentSize; // font-size: enum, length, percent, inherit nscoord scriptLevelAdjustedParentSize = ComputeScriptLevelSize(aFont, aParentFont, aPresContext, &scriptLevelAdjustedUnconstrainedParentSize); NS_ASSERTION(!aUsedStartStruct || aFont->mScriptUnconstrainedSize == aFont->mSize, "If we have a start struct, we should have reset everything coming in here"); // Compute whether we're affected by scriptMinSize *before* calling // SetFontSize, since aParentFont might be the same as aFont. If it // is, calling SetFontSize might throw off our calculation. bool affectedByScriptMinSize = aParentFont->mSize != aParentFont->mScriptUnconstrainedSize || scriptLevelAdjustedParentSize != scriptLevelAdjustedUnconstrainedParentSize; SetFontSize(aPresContext, aContext, aRuleData, aFont, aParentFont, &aFont->mSize, systemFont, aParentFont->mSize, scriptLevelAdjustedParentSize, aUsedStartStruct, atRoot, aConditions); if (!aPresContext->Document()->GetMathMLEnabled()) { MOZ_ASSERT(!affectedByScriptMinSize); // If MathML is not enabled, we don't need to mark this node as // uncacheable. If it becomes enabled, code in // nsMathMLElementFactory will rebuild the rule tree and style data // when MathML is first enabled (see nsMathMLElement::BindToTree). aFont->mScriptUnconstrainedSize = aFont->mSize; } else if (!affectedByScriptMinSize) { // Fast path: we have not been affected by scriptminsize so we don't // need to call SetFontSize again to compute the // scriptminsize-unconstrained size. This is OK even if we have a // start struct, because if we have a start struct then 'font-size' // was specified and so scriptminsize has no effect. aFont->mScriptUnconstrainedSize = aFont->mSize; // It's possible we could, in the future, have a different parent, // which would lead to a different affectedByScriptMinSize. aConditions.SetUncacheable(); } else { // see previous else-if aConditions.SetUncacheable(); // Use a separate conditions object because it might get a // *different* font-size dependency. We can ignore it because we've // already called SetUncacheable. RuleNodeCacheConditions unconstrainedConditions; SetFontSize(aPresContext, aContext, aRuleData, aFont, aParentFont, &aFont->mScriptUnconstrainedSize, systemFont, aParentFont->mScriptUnconstrainedSize, scriptLevelAdjustedUnconstrainedParentSize, aUsedStartStruct, atRoot, unconstrainedConditions); } NS_ASSERTION(aFont->mScriptUnconstrainedSize <= aFont->mSize, "scriptminsize should never be making things bigger"); nscoord fontSize = aFont->mSize; // enforce the user' specified minimum font-size on the value that we expose // (but don't change font-size:0, since that would unhide hidden text) if (fontSize > 0) { nscoord minFontSize = aPresContext->MinFontSize(aFont->mLanguage); if (minFontSize < 0) { minFontSize = 0; } else { minFontSize = (minFontSize * aFont->mMinFontSizeRatio) / 100; } if (fontSize < minFontSize && !aPresContext->IsChrome()) { // override the minimum font-size constraint fontSize = minFontSize; } } aFont->mFont.size = fontSize; // font-size-adjust: number, none, inherit, initial, -moz-system-font const nsCSSValue* sizeAdjustValue = aRuleData->ValueForFontSizeAdjust(); if (eCSSUnit_System_Font == sizeAdjustValue->GetUnit()) { aFont->mFont.sizeAdjust = systemFont.sizeAdjust; } else SetFactor(*sizeAdjustValue, aFont->mFont.sizeAdjust, aConditions, aParentFont->mFont.sizeAdjust, -1.0f, SETFCT_NONE | SETFCT_UNSET_INHERIT); } /* static */ void nsRuleNode::ComputeFontFeatures(const nsCSSValuePairList *aFeaturesList, nsTArray<gfxFontFeature>& aFeatureSettings) { aFeatureSettings.Clear(); for (const nsCSSValuePairList* p = aFeaturesList; p; p = p->mNext) { gfxFontFeature feat = {0, 0}; MOZ_ASSERT(aFeaturesList->mXValue.GetUnit() == eCSSUnit_String, "unexpected value unit"); // tag is a 4-byte ASCII sequence nsAutoString tag; p->mXValue.GetStringValue(tag); if (tag.Length() != 4) { continue; } // parsing validates that these are ASCII chars // tags are always big-endian feat.mTag = (tag[0] << 24) | (tag[1] << 16) | (tag[2] << 8) | tag[3]; // value NS_ASSERTION(p->mYValue.GetUnit() == eCSSUnit_Integer, "should have found an integer unit"); feat.mValue = p->mYValue.GetIntValue(); aFeatureSettings.AppendElement(feat); } } // This should die (bug 380915). // // SetGenericFont: // - backtrack to an ancestor with the same generic font name (possibly // up to the root where default values come from the presentation context) // - re-apply cascading rules from there without caching intermediate values /* static */ void nsRuleNode::SetGenericFont(nsPresContext* aPresContext, nsStyleContext* aContext, uint8_t aGenericFontID, nsStyleFont* aFont) { // walk up the contexts until a context with the desired generic font AutoTArray<nsStyleContext*, 8> contextPath; contextPath.AppendElement(aContext); nsStyleContext* higherContext = aContext->GetParent(); while (higherContext) { if (higherContext->StyleFont()->mGenericID == aGenericFontID) { // done walking up the higher contexts break; } contextPath.AppendElement(higherContext); higherContext = higherContext->GetParent(); } // re-apply the cascading rules, starting from the higher context // If we stopped earlier because we reached the root of the style tree, // we will start with the default generic font from the presentation // context. Otherwise we start with the higher context. const nsFont* defaultFont = aPresContext->GetDefaultFont(aGenericFontID, aFont->mLanguage); nsStyleFont parentFont(*defaultFont, aPresContext); if (higherContext) { const nsStyleFont* tmpFont = higherContext->StyleFont(); parentFont = *tmpFont; } *aFont = parentFont; uint32_t fontBit = nsCachedStyleData::GetBitForSID(eStyleStruct_Font); // use placement new[] on the result of alloca() to allocate a // variable-sized stack array, including execution of constructors, // and use an RAII class to run the destructors too. size_t nprops = nsCSSProps::PropertyCountInStruct(eStyleStruct_Font); void* dataStorage = alloca(nprops * sizeof(nsCSSValue)); for (int32_t i = contextPath.Length() - 1; i >= 0; --i) { nsStyleContext* context = contextPath[i]; AutoCSSValueArray dataArray(dataStorage, nprops); nsRuleData ruleData(NS_STYLE_INHERIT_BIT(Font), dataArray.get(), aPresContext, context); ruleData.mValueOffsets[eStyleStruct_Font] = 0; // Trimmed down version of ::WalkRuleTree() to re-apply the style rules // Note that we *do* need to do this for our own data, since what is // in |fontData| in ComputeFontData is only for the rules below // aStartStruct. for (nsRuleNode* ruleNode = context->RuleNode(); ruleNode; ruleNode = ruleNode->GetParent()) { if (ruleNode->mNoneBits & fontBit) // no more font rules on this branch, get out break; nsIStyleRule *rule = ruleNode->GetRule(); if (rule) { ruleData.mLevel = ruleNode->GetLevel(); ruleData.mIsImportantRule = ruleNode->IsImportantRule(); rule->MapRuleInfoInto(&ruleData); } } // Compute the delta from the information that the rules specified // Avoid unnecessary operations in SetFont(). But we care if it's // the final value that we're computing. if (i != 0) ruleData.ValueForFontFamily()->Reset(); ResolveVariableReferences(eStyleStruct_Font, &ruleData, aContext); RuleNodeCacheConditions dummy; nsRuleNode::SetFont(aPresContext, context, aGenericFontID, &ruleData, &parentFont, aFont, false, dummy); parentFont = *aFont; } if (higherContext && contextPath.Length() > 1) { // contextPath is a list of all ancestor style contexts, so it must have // at least two elements for it to result in a dependency on grandancestor // styles. PropagateGrandancestorBit(aContext, higherContext); } } const void* nsRuleNode::ComputeFontData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(Font, font, parentFont) // NOTE: The |aRuleDetail| passed in is a little bit conservative due // to the -moz-system-font property. We really don't need to consider // it here in determining whether to cache in the rule tree. However, // we do need to consider it in WalkRuleTree when deciding whether to // walk further up the tree. So this means that when the font struct // is fully specified using *longhand* properties (excluding // -moz-system-font), we won't cache in the rule tree even though we // could. However, it's pretty unlikely authors will do that // (although there is a pretty good chance they'll fully specify it // using the 'font' shorthand). // Figure out if we are a generic font uint8_t generic = kGenericFont_NONE; // XXXldb What if we would have had a string if we hadn't been doing // the optimization with a non-null aStartStruct? const nsCSSValue* familyValue = aRuleData->ValueForFontFamily(); if (eCSSUnit_FontFamilyList == familyValue->GetUnit()) { const FontFamilyList* fontlist = familyValue->GetFontFamilyListValue(); FontFamilyList& fl = font->mFont.fontlist; fl = *fontlist; // extract the first generic in the fontlist, if exists FontFamilyType fontType = fontlist->FirstGeneric(); // if only a single generic, set the generic type if (fontlist->Length() == 1) { switch (fontType) { case eFamily_serif: generic = kGenericFont_serif; break; case eFamily_sans_serif: generic = kGenericFont_sans_serif; break; case eFamily_monospace: generic = kGenericFont_monospace; break; case eFamily_cursive: generic = kGenericFont_cursive; break; case eFamily_fantasy: generic = kGenericFont_fantasy; break; case eFamily_moz_fixed: generic = kGenericFont_moz_fixed; break; default: break; } } } // Now compute our font struct if (generic == kGenericFont_NONE) { // continue the normal processing nsRuleNode::SetFont(mPresContext, aContext, generic, aRuleData, parentFont, font, aStartStruct != nullptr, conditions); } else { // re-calculate the font as a generic font conditions.SetUncacheable(); nsRuleNode::SetGenericFont(mPresContext, aContext, generic, font); } COMPUTE_END_INHERITED(Font, font) } template <typename T> inline uint32_t ListLength(const T* aList) { uint32_t len = 0; while (aList) { len++; aList = aList->mNext; } return len; } static already_AddRefed<nsCSSShadowArray> GetShadowData(const nsCSSValueList* aList, nsStyleContext* aContext, bool aIsBoxShadow, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { uint32_t arrayLength = ListLength(aList); MOZ_ASSERT(arrayLength > 0, "Non-null text-shadow list, yet we counted 0 items."); RefPtr<nsCSSShadowArray> shadowList = new(arrayLength) nsCSSShadowArray(arrayLength); if (!shadowList) return nullptr; nsStyleCoord tempCoord; DebugOnly<bool> unitOK; for (nsCSSShadowItem* item = shadowList->ShadowAt(0); aList; aList = aList->mNext, ++item) { MOZ_ASSERT(aList->mValue.GetUnit() == eCSSUnit_Array, "expecting a plain array value"); nsCSSValue::Array *arr = aList->mValue.GetArrayValue(); // OK to pass bad aParentCoord since we're not passing SETCOORD_INHERIT unitOK = SetCoord(arr->Item(0), tempCoord, nsStyleCoord(), SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY, aContext, aPresContext, aConditions); NS_ASSERTION(unitOK, "unexpected unit"); item->mXOffset = tempCoord.GetCoordValue(); unitOK = SetCoord(arr->Item(1), tempCoord, nsStyleCoord(), SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY, aContext, aPresContext, aConditions); NS_ASSERTION(unitOK, "unexpected unit"); item->mYOffset = tempCoord.GetCoordValue(); // Blur radius is optional in the current box-shadow spec if (arr->Item(2).GetUnit() != eCSSUnit_Null) { unitOK = SetCoord(arr->Item(2), tempCoord, nsStyleCoord(), SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_CALC_CLAMP_NONNEGATIVE, aContext, aPresContext, aConditions); NS_ASSERTION(unitOK, "unexpected unit"); item->mRadius = tempCoord.GetCoordValue(); } else { item->mRadius = 0; } // Find the spread radius if (aIsBoxShadow && arr->Item(3).GetUnit() != eCSSUnit_Null) { unitOK = SetCoord(arr->Item(3), tempCoord, nsStyleCoord(), SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY, aContext, aPresContext, aConditions); NS_ASSERTION(unitOK, "unexpected unit"); item->mSpread = tempCoord.GetCoordValue(); } else { item->mSpread = 0; } if (arr->Item(4).GetUnit() != eCSSUnit_Null) { item->mHasColor = true; // 2nd argument can be bogus since inherit is not a valid color unitOK = SetColor(arr->Item(4), 0, aPresContext, aContext, item->mColor, aConditions); NS_ASSERTION(unitOK, "unexpected unit"); } if (aIsBoxShadow && arr->Item(5).GetUnit() == eCSSUnit_Enumerated) { NS_ASSERTION(arr->Item(5).GetIntValue() == uint8_t(StyleBoxShadowType::Inset), "invalid keyword type for box shadow"); item->mInset = true; } else { item->mInset = false; } } return shadowList.forget(); } struct TextEmphasisChars { const char16_t* mFilled; const char16_t* mOpen; }; #define TEXT_EMPHASIS_CHARS_LIST() \ TEXT_EMPHASIS_CHARS_ITEM(u"", u"", NONE) \ TEXT_EMPHASIS_CHARS_ITEM(u"\u2022", u"\u25e6", DOT) \ TEXT_EMPHASIS_CHARS_ITEM(u"\u25cf", u"\u25cb", CIRCLE) \ TEXT_EMPHASIS_CHARS_ITEM(u"\u25c9", u"\u25ce", DOUBLE_CIRCLE) \ TEXT_EMPHASIS_CHARS_ITEM(u"\u25b2", u"\u25b3", TRIANGLE) \ TEXT_EMPHASIS_CHARS_ITEM(u"\ufe45", u"\ufe46", SESAME) static constexpr TextEmphasisChars kTextEmphasisChars[] = { #define TEXT_EMPHASIS_CHARS_ITEM(filled_, open_, type_) \ { filled_, open_ }, // type_ TEXT_EMPHASIS_CHARS_LIST() #undef TEXT_EMPHASIS_CHARS_ITEM }; #define TEXT_EMPHASIS_CHARS_ITEM(filled_, open_, type_) \ static_assert(ArrayLength(filled_) <= 2 && \ ArrayLength(open_) <= 2, \ "emphasis marks should have no more than one char"); \ static_assert( \ *kTextEmphasisChars[NS_STYLE_TEXT_EMPHASIS_STYLE_##type_].mFilled == \ *filled_, "filled " #type_ " should be " #filled_); \ static_assert( \ *kTextEmphasisChars[NS_STYLE_TEXT_EMPHASIS_STYLE_##type_].mOpen == \ *open_, "open " #type_ " should be " #open_); TEXT_EMPHASIS_CHARS_LIST() #undef TEXT_EMPHASIS_CHARS_ITEM #undef TEXT_EMPHASIS_CHARS_LIST static void TruncateStringToSingleGrapheme(nsAString& aStr) { unicode::ClusterIterator iter(aStr.Data(), aStr.Length()); if (!iter.AtEnd()) { iter.Next(); if (!iter.AtEnd()) { // Not mutating the string for common cases helps memory use // since we share the buffer from the specified style into the // computed style. aStr.Truncate(iter - aStr.Data()); } } } struct LineHeightCalcObj { float mLineHeight; bool mIsNumber; }; struct SetLineHeightCalcOps : public css::NumbersAlreadyNormalizedOps { typedef LineHeightCalcObj result_type; nsStyleContext* const mStyleContext; nsPresContext* const mPresContext; RuleNodeCacheConditions& mConditions; SetLineHeightCalcOps(nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) : mStyleContext(aStyleContext), mPresContext(aPresContext), mConditions(aConditions) { } result_type MergeAdditive(nsCSSUnit aCalcFunction, result_type aValue1, result_type aValue2) { MOZ_ASSERT(aValue1.mIsNumber == aValue2.mIsNumber); LineHeightCalcObj result; result.mIsNumber = aValue1.mIsNumber; if (aCalcFunction == eCSSUnit_Calc_Plus) { result.mLineHeight = aValue1.mLineHeight + aValue2.mLineHeight; return result; } MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Minus, "unexpected unit"); result.mLineHeight = aValue1.mLineHeight - aValue2.mLineHeight; return result; } result_type MergeMultiplicativeL(nsCSSUnit aCalcFunction, float aValue1, result_type aValue2) { MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Times_L, "unexpected unit"); LineHeightCalcObj result; result.mIsNumber = aValue2.mIsNumber; result.mLineHeight = aValue1 * aValue2.mLineHeight; return result; } result_type MergeMultiplicativeR(nsCSSUnit aCalcFunction, result_type aValue1, float aValue2) { LineHeightCalcObj result; result.mIsNumber = aValue1.mIsNumber; if (aCalcFunction == eCSSUnit_Calc_Times_R) { result.mLineHeight = aValue1.mLineHeight * aValue2; return result; } MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Divided, "unexpected unit"); result.mLineHeight = aValue1.mLineHeight / aValue2; return result; } result_type ComputeLeafValue(const nsCSSValue& aValue) { LineHeightCalcObj result; if (aValue.IsLengthUnit()) { result.mIsNumber = false; result.mLineHeight = CalcLength(aValue, mStyleContext, mPresContext, mConditions); } else if (eCSSUnit_Percent == aValue.GetUnit()) { mConditions.SetUncacheable(); result.mIsNumber = false; nscoord fontSize = mStyleContext->StyleFont()->mFont.size; result.mLineHeight = fontSize * aValue.GetPercentValue(); } else if (eCSSUnit_Number == aValue.GetUnit()) { result.mIsNumber = true; result.mLineHeight = aValue.GetFloatValue(); } else { MOZ_ASSERT(false, "unexpected value"); result.mIsNumber = true; result.mLineHeight = 1.0f; } return result; } }; const void* nsRuleNode::ComputeTextData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(Text, text, parentText) auto setComplexColor = [&](const nsCSSValue* aValue, StyleComplexColor nsStyleText::* aField) { SetComplexColor<eUnsetInherit>(*aValue, parentText->*aField, StyleComplexColor::CurrentColor(), mPresContext, text->*aField, conditions); }; // tab-size: integer, inherit SetValue(*aRuleData->ValueForTabSize(), text->mTabSize, conditions, SETVAL_INTEGER | SETVAL_UNSET_INHERIT, parentText->mTabSize, NS_STYLE_TABSIZE_INITIAL); // letter-spacing: normal, length, inherit SetCoord(*aRuleData->ValueForLetterSpacing(), text->mLetterSpacing, parentText->mLetterSpacing, SETCOORD_LH | SETCOORD_NORMAL | SETCOORD_INITIAL_NORMAL | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); // text-shadow: none, list, inherit, initial const nsCSSValue* textShadowValue = aRuleData->ValueForTextShadow(); if (textShadowValue->GetUnit() != eCSSUnit_Null) { text->mTextShadow = nullptr; // Don't need to handle none/initial explicitly: The above assignment // takes care of that if (textShadowValue->GetUnit() == eCSSUnit_Inherit || textShadowValue->GetUnit() == eCSSUnit_Unset) { conditions.SetUncacheable(); text->mTextShadow = parentText->mTextShadow; } else if (textShadowValue->GetUnit() == eCSSUnit_List || textShadowValue->GetUnit() == eCSSUnit_ListDep) { // List of arrays text->mTextShadow = GetShadowData(textShadowValue->GetListValue(), aContext, false, mPresContext, conditions); } } // line-height: normal, number, length, percent, calc, inherit const nsCSSValue* lineHeightValue = aRuleData->ValueForLineHeight(); if (eCSSUnit_Percent == lineHeightValue->GetUnit()) { conditions.SetUncacheable(); // Use |mFont.size| to pick up minimum font size. text->mLineHeight.SetCoordValue( NSToCoordRound(float(aContext->StyleFont()->mFont.size) * lineHeightValue->GetPercentValue())); } else if (eCSSUnit_Initial == lineHeightValue->GetUnit() || eCSSUnit_System_Font == lineHeightValue->GetUnit()) { text->mLineHeight.SetNormalValue(); } else if (eCSSUnit_Calc == lineHeightValue->GetUnit()) { SetLineHeightCalcOps ops(aContext, mPresContext, conditions); LineHeightCalcObj obj = css::ComputeCalc(*lineHeightValue, ops); if (obj.mIsNumber) { text->mLineHeight.SetFactorValue(obj.mLineHeight); } else { text->mLineHeight.SetCoordValue( NSToCoordRoundWithClamp(obj.mLineHeight)); } } else { SetCoord(*lineHeightValue, text->mLineHeight, parentText->mLineHeight, SETCOORD_LEH | SETCOORD_FACTOR | SETCOORD_NORMAL | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); if (lineHeightValue->IsLengthUnit() && !lineHeightValue->IsRelativeLengthUnit()) { nscoord lh = nsStyleFont::ZoomText(mPresContext, text->mLineHeight.GetCoordValue()); conditions.SetUncacheable(); const nsStyleFont *font = aContext->StyleFont(); nscoord minimumFontSize = mPresContext->MinFontSize(font->mLanguage); if (minimumFontSize > 0 && !mPresContext->IsChrome()) { if (font->mSize != 0) { lh = nscoord(float(lh) * float(font->mFont.size) / float(font->mSize)); } else { // Never shrink line heights as a result of minFontSize lh = std::max(lh, minimumFontSize); } } text->mLineHeight.SetCoordValue(lh); } } // text-align: enum, string, pair(enum|string), inherit, initial // NOTE: string is not implemented yet. const nsCSSValue* textAlignValue = aRuleData->ValueForTextAlign(); text->mTextAlignTrue = false; if (eCSSUnit_String == textAlignValue->GetUnit()) { NS_NOTYETIMPLEMENTED("align string"); } else if (eCSSUnit_Enumerated == textAlignValue->GetUnit() && NS_STYLE_TEXT_ALIGN_MOZ_CENTER_OR_INHERIT == textAlignValue->GetIntValue()) { conditions.SetUncacheable(); uint8_t parentAlign = parentText->mTextAlign; text->mTextAlign = (NS_STYLE_TEXT_ALIGN_START == parentAlign) ? NS_STYLE_TEXT_ALIGN_CENTER : parentAlign; } else if (eCSSUnit_Enumerated == textAlignValue->GetUnit() && NS_STYLE_TEXT_ALIGN_MATCH_PARENT == textAlignValue->GetIntValue()) { conditions.SetUncacheable(); nsStyleContext* parent = aContext->GetParent(); if (parent) { uint8_t parentAlign = parentText->mTextAlign; uint8_t parentDirection = parent->StyleVisibility()->mDirection; switch (parentAlign) { case NS_STYLE_TEXT_ALIGN_START: text->mTextAlign = parentDirection == NS_STYLE_DIRECTION_RTL ? NS_STYLE_TEXT_ALIGN_RIGHT : NS_STYLE_TEXT_ALIGN_LEFT; break; case NS_STYLE_TEXT_ALIGN_END: text->mTextAlign = parentDirection == NS_STYLE_DIRECTION_RTL ? NS_STYLE_TEXT_ALIGN_LEFT : NS_STYLE_TEXT_ALIGN_RIGHT; break; default: text->mTextAlign = parentAlign; } } } else { if (eCSSUnit_Pair == textAlignValue->GetUnit()) { // Two values were specified, one must be 'true'. text->mTextAlignTrue = true; const nsCSSValuePair& textAlignValuePair = textAlignValue->GetPairValue(); textAlignValue = &textAlignValuePair.mXValue; if (eCSSUnit_Enumerated == textAlignValue->GetUnit()) { if (textAlignValue->GetIntValue() == NS_STYLE_TEXT_ALIGN_UNSAFE) { textAlignValue = &textAlignValuePair.mYValue; } } else if (eCSSUnit_String == textAlignValue->GetUnit()) { NS_NOTYETIMPLEMENTED("align string"); } } else if (eCSSUnit_Inherit == textAlignValue->GetUnit() || eCSSUnit_Unset == textAlignValue->GetUnit()) { text->mTextAlignTrue = parentText->mTextAlignTrue; } SetValue(*textAlignValue, text->mTextAlign, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mTextAlign, NS_STYLE_TEXT_ALIGN_START); } // text-align-last: enum, pair(enum), inherit, initial const nsCSSValue* textAlignLastValue = aRuleData->ValueForTextAlignLast(); text->mTextAlignLastTrue = false; if (eCSSUnit_Pair == textAlignLastValue->GetUnit()) { // Two values were specified, one must be 'true'. text->mTextAlignLastTrue = true; const nsCSSValuePair& textAlignLastValuePair = textAlignLastValue->GetPairValue(); textAlignLastValue = &textAlignLastValuePair.mXValue; if (eCSSUnit_Enumerated == textAlignLastValue->GetUnit()) { if (textAlignLastValue->GetIntValue() == NS_STYLE_TEXT_ALIGN_UNSAFE) { textAlignLastValue = &textAlignLastValuePair.mYValue; } } } else if (eCSSUnit_Inherit == textAlignLastValue->GetUnit() || eCSSUnit_Unset == textAlignLastValue->GetUnit()) { text->mTextAlignLastTrue = parentText->mTextAlignLastTrue; } SetValue(*textAlignLastValue, text->mTextAlignLast, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mTextAlignLast, NS_STYLE_TEXT_ALIGN_AUTO); // text-indent: length, percent, calc, inherit, initial SetCoord(*aRuleData->ValueForTextIndent(), text->mTextIndent, parentText->mTextIndent, SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); // text-justify: enum, inherit, initial SetValue(*aRuleData->ValueForTextJustify(), text->mTextJustify, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mTextJustify, StyleTextJustify::Auto); // text-transform: enum, inherit, initial SetValue(*aRuleData->ValueForTextTransform(), text->mTextTransform, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mTextTransform, NS_STYLE_TEXT_TRANSFORM_NONE); // white-space: enum, inherit, initial SetValue(*aRuleData->ValueForWhiteSpace(), text->mWhiteSpace, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mWhiteSpace, NS_STYLE_WHITESPACE_NORMAL); // word-break: enum, inherit, initial SetValue(*aRuleData->ValueForWordBreak(), text->mWordBreak, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mWordBreak, NS_STYLE_WORDBREAK_NORMAL); // word-spacing: normal, length, percent, inherit const nsCSSValue* wordSpacingValue = aRuleData->ValueForWordSpacing(); if (wordSpacingValue->GetUnit() == eCSSUnit_Normal) { // Do this so that "normal" computes to 0px, as the CSS 2.1 spec requires. text->mWordSpacing.SetCoordValue(0); } else { SetCoord(*aRuleData->ValueForWordSpacing(), text->mWordSpacing, parentText->mWordSpacing, SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); } // overflow-wrap: enum, inherit, initial SetValue(*aRuleData->ValueForOverflowWrap(), text->mOverflowWrap, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mOverflowWrap, NS_STYLE_OVERFLOWWRAP_NORMAL); // hyphens: enum, inherit, initial SetValue(*aRuleData->ValueForHyphens(), text->mHyphens, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mHyphens, NS_STYLE_HYPHENS_MANUAL); // ruby-align: enum, inherit, initial SetValue(*aRuleData->ValueForRubyAlign(), text->mRubyAlign, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mRubyAlign, NS_STYLE_RUBY_ALIGN_SPACE_AROUND); // ruby-position: enum, inherit, initial SetValue(*aRuleData->ValueForRubyPosition(), text->mRubyPosition, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mRubyPosition, NS_STYLE_RUBY_POSITION_OVER); // text-size-adjust: none, auto, inherit, initial SetValue(*aRuleData->ValueForTextSizeAdjust(), text->mTextSizeAdjust, conditions, SETVAL_UNSET_INHERIT, parentText->mTextSizeAdjust, /* initial */ NS_STYLE_TEXT_SIZE_ADJUST_AUTO, /* auto */ NS_STYLE_TEXT_SIZE_ADJUST_AUTO, /* none */ NS_STYLE_TEXT_SIZE_ADJUST_NONE, Unused, Unused); // text-combine-upright: enum, inherit, initial SetValue(*aRuleData->ValueForTextCombineUpright(), text->mTextCombineUpright, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mTextCombineUpright, NS_STYLE_TEXT_COMBINE_UPRIGHT_NONE); // text-emphasis-color: color, string, inherit, initial setComplexColor(aRuleData->ValueForTextEmphasisColor(), &nsStyleText::mTextEmphasisColor); // text-emphasis-position: enum, inherit, initial SetValue(*aRuleData->ValueForTextEmphasisPosition(), text->mTextEmphasisPosition, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mTextEmphasisPosition, NS_STYLE_TEXT_EMPHASIS_POSITION_OVER | NS_STYLE_TEXT_EMPHASIS_POSITION_RIGHT); // text-emphasis-style: string, enum, inherit, initial const nsCSSValue* textEmphasisStyleValue = aRuleData->ValueForTextEmphasisStyle(); switch (textEmphasisStyleValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_None: { text->mTextEmphasisStyle = NS_STYLE_TEXT_EMPHASIS_STYLE_NONE; text->mTextEmphasisStyleString = u""; break; } case eCSSUnit_Inherit: case eCSSUnit_Unset: { conditions.SetUncacheable(); text->mTextEmphasisStyle = parentText->mTextEmphasisStyle; text->mTextEmphasisStyleString = parentText->mTextEmphasisStyleString; break; } case eCSSUnit_Enumerated: { auto style = textEmphasisStyleValue->GetIntValue(); // If shape part is not specified, compute it according to the // writing-mode. Note that, if the fill part (filled/open) is not // specified, we compute it to filled per spec. Since that value // is zero, no additional computation is needed. See the assertion // in CSSParserImpl::ParseTextEmphasisStyle(). if (!(style & NS_STYLE_TEXT_EMPHASIS_STYLE_SHAPE_MASK)) { conditions.SetUncacheable(); if (WritingMode(aContext).IsVertical()) { style |= NS_STYLE_TEXT_EMPHASIS_STYLE_SESAME; } else { style |= NS_STYLE_TEXT_EMPHASIS_STYLE_CIRCLE; } } text->mTextEmphasisStyle = style; size_t shape = style & NS_STYLE_TEXT_EMPHASIS_STYLE_SHAPE_MASK; MOZ_ASSERT(shape > 0 && shape < ArrayLength(kTextEmphasisChars)); const TextEmphasisChars& chars = kTextEmphasisChars[shape]; text->mTextEmphasisStyleString = (style & NS_STYLE_TEXT_EMPHASIS_STYLE_FILL_MASK) == NS_STYLE_TEXT_EMPHASIS_STYLE_FILLED ? chars.mFilled : chars.mOpen; break; } case eCSSUnit_String: { text->mTextEmphasisStyle = NS_STYLE_TEXT_EMPHASIS_STYLE_STRING; nsString strValue; textEmphasisStyleValue->GetStringValue(strValue); TruncateStringToSingleGrapheme(strValue); text->mTextEmphasisStyleString = strValue; break; } default: MOZ_ASSERT_UNREACHABLE("Unknown value unit type"); } // text-rendering: enum, inherit, initial SetValue(*aRuleData->ValueForTextRendering(), text->mTextRendering, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mTextRendering, NS_STYLE_TEXT_RENDERING_AUTO); // -webkit-text-fill-color: color, string, inherit, initial setComplexColor(aRuleData->ValueForWebkitTextFillColor(), &nsStyleText::mWebkitTextFillColor); // -webkit-text-stroke-color: color, string, inherit, initial setComplexColor(aRuleData->ValueForWebkitTextStrokeColor(), &nsStyleText::mWebkitTextStrokeColor); // -webkit-text-stroke-width: length, inherit, initial, enum const nsCSSValue* webkitTextStrokeWidthValue = aRuleData->ValueForWebkitTextStrokeWidth(); if (webkitTextStrokeWidthValue->GetUnit() == eCSSUnit_Enumerated) { NS_ASSERTION(webkitTextStrokeWidthValue->GetIntValue() == NS_STYLE_BORDER_WIDTH_THIN || webkitTextStrokeWidthValue->GetIntValue() == NS_STYLE_BORDER_WIDTH_MEDIUM || webkitTextStrokeWidthValue->GetIntValue() == NS_STYLE_BORDER_WIDTH_THICK, "Unexpected enum value"); text->mWebkitTextStrokeWidth.SetCoordValue( mPresContext->GetBorderWidthTable()[webkitTextStrokeWidthValue->GetIntValue()]); } else { SetCoord(*webkitTextStrokeWidthValue, text->mWebkitTextStrokeWidth, parentText->mWebkitTextStrokeWidth, SETCOORD_LH | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_CALC_CLAMP_NONNEGATIVE | SETCOORD_INITIAL_ZERO | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); } // -moz-control-character-visibility: enum, inherit, initial SetValue(*aRuleData->ValueForControlCharacterVisibility(), text->mControlCharacterVisibility, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentText->mControlCharacterVisibility, nsCSSParser::ControlCharVisibilityDefault()); COMPUTE_END_INHERITED(Text, text) } const void* nsRuleNode::ComputeTextResetData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(TextReset, text, parentText) // text-decoration-line: enum (bit field), inherit, initial const nsCSSValue* decorationLineValue = aRuleData->ValueForTextDecorationLine(); if (eCSSUnit_Enumerated == decorationLineValue->GetUnit()) { int32_t td = decorationLineValue->GetIntValue(); text->mTextDecorationLine = td; if (td & NS_STYLE_TEXT_DECORATION_LINE_PREF_ANCHORS) { bool underlineLinks = mPresContext->GetCachedBoolPref(kPresContext_UnderlineLinks); if (underlineLinks) { text->mTextDecorationLine |= NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE; } else { text->mTextDecorationLine &= ~NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE; } } } else if (eCSSUnit_Inherit == decorationLineValue->GetUnit()) { conditions.SetUncacheable(); text->mTextDecorationLine = parentText->mTextDecorationLine; } else if (eCSSUnit_Initial == decorationLineValue->GetUnit() || eCSSUnit_Unset == decorationLineValue->GetUnit()) { text->mTextDecorationLine = NS_STYLE_TEXT_DECORATION_LINE_NONE; } // text-decoration-color: color, string, enum, inherit, initial SetComplexColor<eUnsetInitial>(*aRuleData->ValueForTextDecorationColor(), parentText->mTextDecorationColor, StyleComplexColor::CurrentColor(), mPresContext, text->mTextDecorationColor, conditions); // text-decoration-style: enum, inherit, initial const nsCSSValue* decorationStyleValue = aRuleData->ValueForTextDecorationStyle(); if (eCSSUnit_Enumerated == decorationStyleValue->GetUnit()) { text->mTextDecorationStyle = decorationStyleValue->GetIntValue(); } else if (eCSSUnit_Inherit == decorationStyleValue->GetUnit()) { text->mTextDecorationStyle = parentText->mTextDecorationStyle; conditions.SetUncacheable(); } else if (eCSSUnit_Initial == decorationStyleValue->GetUnit() || eCSSUnit_Unset == decorationStyleValue->GetUnit()) { text->mTextDecorationStyle = NS_STYLE_TEXT_DECORATION_STYLE_SOLID; } // text-overflow: enum, string, pair(enum|string), inherit, initial const nsCSSValue* textOverflowValue = aRuleData->ValueForTextOverflow(); if (eCSSUnit_Initial == textOverflowValue->GetUnit() || eCSSUnit_Unset == textOverflowValue->GetUnit()) { text->mTextOverflow = nsStyleTextOverflow(); } else if (eCSSUnit_Inherit == textOverflowValue->GetUnit()) { conditions.SetUncacheable(); text->mTextOverflow = parentText->mTextOverflow; } else if (eCSSUnit_Enumerated == textOverflowValue->GetUnit()) { // A single enumerated value. SetValue(*textOverflowValue, text->mTextOverflow.mRight.mType, conditions, SETVAL_ENUMERATED, parentText->mTextOverflow.mRight.mType, NS_STYLE_TEXT_OVERFLOW_CLIP); text->mTextOverflow.mRight.mString.Truncate(); text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_CLIP; text->mTextOverflow.mLeft.mString.Truncate(); text->mTextOverflow.mLogicalDirections = true; } else if (eCSSUnit_String == textOverflowValue->GetUnit()) { // A single string value. text->mTextOverflow.mRight.mType = NS_STYLE_TEXT_OVERFLOW_STRING; textOverflowValue->GetStringValue(text->mTextOverflow.mRight.mString); text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_CLIP; text->mTextOverflow.mLeft.mString.Truncate(); text->mTextOverflow.mLogicalDirections = true; } else if (eCSSUnit_Pair == textOverflowValue->GetUnit()) { // Two values were specified. text->mTextOverflow.mLogicalDirections = false; const nsCSSValuePair& textOverflowValuePair = textOverflowValue->GetPairValue(); const nsCSSValue *textOverflowLeftValue = &textOverflowValuePair.mXValue; if (eCSSUnit_Enumerated == textOverflowLeftValue->GetUnit()) { SetValue(*textOverflowLeftValue, text->mTextOverflow.mLeft.mType, conditions, SETVAL_ENUMERATED, parentText->mTextOverflow.mLeft.mType, NS_STYLE_TEXT_OVERFLOW_CLIP); text->mTextOverflow.mLeft.mString.Truncate(); } else if (eCSSUnit_String == textOverflowLeftValue->GetUnit()) { textOverflowLeftValue->GetStringValue(text->mTextOverflow.mLeft.mString); text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_STRING; } const nsCSSValue *textOverflowRightValue = &textOverflowValuePair.mYValue; if (eCSSUnit_Enumerated == textOverflowRightValue->GetUnit()) { SetValue(*textOverflowRightValue, text->mTextOverflow.mRight.mType, conditions, SETVAL_ENUMERATED, parentText->mTextOverflow.mRight.mType, NS_STYLE_TEXT_OVERFLOW_CLIP); text->mTextOverflow.mRight.mString.Truncate(); } else if (eCSSUnit_String == textOverflowRightValue->GetUnit()) { textOverflowRightValue->GetStringValue(text->mTextOverflow.mRight.mString); text->mTextOverflow.mRight.mType = NS_STYLE_TEXT_OVERFLOW_STRING; } } // unicode-bidi: enum, inherit, initial SetValue(*aRuleData->ValueForUnicodeBidi(), text->mUnicodeBidi, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentText->mUnicodeBidi, NS_STYLE_UNICODE_BIDI_NORMAL); // initial-letter: normal, number, array(number, integer?), initial const nsCSSValue* initialLetterValue = aRuleData->ValueForInitialLetter(); if (initialLetterValue->GetUnit() == eCSSUnit_Null) { // We don't want to change anything in this case. } else if (initialLetterValue->GetUnit() == eCSSUnit_Inherit) { conditions.SetUncacheable(); text->mInitialLetterSink = parentText->mInitialLetterSink; text->mInitialLetterSize = parentText->mInitialLetterSize; } else if (initialLetterValue->GetUnit() == eCSSUnit_Initial || initialLetterValue->GetUnit() == eCSSUnit_Unset || initialLetterValue->GetUnit() == eCSSUnit_Normal) { // Use invalid values in initial-letter property to mean normal. So we can // determine whether it is normal by checking mInitialLetterSink == 0. text->mInitialLetterSink = 0; text->mInitialLetterSize = 0.0f; } else if (initialLetterValue->GetUnit() == eCSSUnit_Array) { const nsCSSValue& firstValue = initialLetterValue->GetArrayValue()->Item(0); const nsCSSValue& secondValue = initialLetterValue->GetArrayValue()->Item(1); MOZ_ASSERT(firstValue.GetUnit() == eCSSUnit_Number && secondValue.GetUnit() == eCSSUnit_Integer, "unexpected value unit"); text->mInitialLetterSize = firstValue.GetFloatValue(); text->mInitialLetterSink = secondValue.GetIntValue(); } else if (initialLetterValue->GetUnit() == eCSSUnit_Number) { text->mInitialLetterSize = initialLetterValue->GetFloatValue(); text->mInitialLetterSink = NSToCoordFloorClamped(text->mInitialLetterSize); } else { MOZ_ASSERT_UNREACHABLE("unknown unit for initial-letter"); } COMPUTE_END_RESET(TextReset, text) } const void* nsRuleNode::ComputeUserInterfaceData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(UserInterface, ui, parentUI) // cursor: enum, url, inherit const nsCSSValue* cursorValue = aRuleData->ValueForCursor(); nsCSSUnit cursorUnit = cursorValue->GetUnit(); if (cursorUnit != eCSSUnit_Null) { ui->mCursorImages.Clear(); if (cursorUnit == eCSSUnit_Inherit || cursorUnit == eCSSUnit_Unset) { conditions.SetUncacheable(); ui->mCursor = parentUI->mCursor; ui->mCursorImages = parentUI->mCursorImages; } else if (cursorUnit == eCSSUnit_Initial) { ui->mCursor = NS_STYLE_CURSOR_AUTO; } else { // The parser will never create a list that is *all* URL values -- // that's invalid. MOZ_ASSERT(cursorUnit == eCSSUnit_List || cursorUnit == eCSSUnit_ListDep, "unrecognized cursor unit"); const nsCSSValueList* list = cursorValue->GetListValue(); for ( ; list->mValue.GetUnit() == eCSSUnit_Array; list = list->mNext) { nsCSSValue::Array* arr = list->mValue.GetArrayValue(); imgRequestProxy* req = GetImageRequest(aContext->PresContext(), arr->Item(0)); if (req) { nsCursorImage* item = ui->mCursorImages.AppendElement(); item->SetImage(req); if (arr->Item(1).GetUnit() != eCSSUnit_Null) { item->mHaveHotspot = true; item->mHotspotX = arr->Item(1).GetFloatValue(); item->mHotspotY = arr->Item(2).GetFloatValue(); } } } NS_ASSERTION(list, "Must have non-array value at the end"); NS_ASSERTION(list->mValue.GetUnit() == eCSSUnit_Enumerated, "Unexpected fallback value at end of cursor list"); ui->mCursor = list->mValue.GetIntValue(); } } // user-input: enum, inherit, initial SetValue(*aRuleData->ValueForUserInput(), ui->mUserInput, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentUI->mUserInput, StyleUserInput::Auto); // user-modify: enum, inherit, initial SetValue(*aRuleData->ValueForUserModify(), ui->mUserModify, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentUI->mUserModify, StyleUserModify::ReadOnly); // user-focus: enum, inherit, initial SetValue(*aRuleData->ValueForUserFocus(), ui->mUserFocus, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentUI->mUserFocus, StyleUserFocus::None); // pointer-events: enum, inherit, initial SetValue(*aRuleData->ValueForPointerEvents(), ui->mPointerEvents, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentUI->mPointerEvents, NS_STYLE_POINTER_EVENTS_AUTO); COMPUTE_END_INHERITED(UserInterface, ui) } const void* nsRuleNode::ComputeUIResetData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(UIReset, ui, parentUI) // user-select: enum, inherit, initial SetValue(*aRuleData->ValueForUserSelect(), ui->mUserSelect, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentUI->mUserSelect, StyleUserSelect::Auto); // ime-mode: enum, inherit, initial SetValue(*aRuleData->ValueForImeMode(), ui->mIMEMode, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentUI->mIMEMode, NS_STYLE_IME_MODE_AUTO); // force-broken-image-icons: integer, inherit, initial SetValue(*aRuleData->ValueForForceBrokenImageIcon(), ui->mForceBrokenImageIcon, conditions, SETVAL_INTEGER | SETVAL_UNSET_INITIAL, parentUI->mForceBrokenImageIcon, 0); // -moz-window-dragging: enum, inherit, initial SetValue(*aRuleData->ValueForWindowDragging(), ui->mWindowDragging, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentUI->mWindowDragging, StyleWindowDragging::Default); // -moz-window-shadow: enum, inherit, initial SetValue(*aRuleData->ValueForWindowShadow(), ui->mWindowShadow, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentUI->mWindowShadow, NS_STYLE_WINDOW_SHADOW_DEFAULT); COMPUTE_END_RESET(UIReset, ui) } // Information about each transition or animation property that is // constant. struct TransitionPropInfo { nsCSSPropertyID property; // Location of the count of the property's computed value. uint32_t nsStyleDisplay::* sdCount; }; // Each property's index in this array must match its index in the // mutable array |transitionPropData| below. static const TransitionPropInfo transitionPropInfo[4] = { { eCSSProperty_transition_delay, &nsStyleDisplay::mTransitionDelayCount }, { eCSSProperty_transition_duration, &nsStyleDisplay::mTransitionDurationCount }, { eCSSProperty_transition_property, &nsStyleDisplay::mTransitionPropertyCount }, { eCSSProperty_transition_timing_function, &nsStyleDisplay::mTransitionTimingFunctionCount }, }; // Each property's index in this array must match its index in the // mutable array |animationPropData| below. static const TransitionPropInfo animationPropInfo[8] = { { eCSSProperty_animation_delay, &nsStyleDisplay::mAnimationDelayCount }, { eCSSProperty_animation_duration, &nsStyleDisplay::mAnimationDurationCount }, { eCSSProperty_animation_name, &nsStyleDisplay::mAnimationNameCount }, { eCSSProperty_animation_timing_function, &nsStyleDisplay::mAnimationTimingFunctionCount }, { eCSSProperty_animation_direction, &nsStyleDisplay::mAnimationDirectionCount }, { eCSSProperty_animation_fill_mode, &nsStyleDisplay::mAnimationFillModeCount }, { eCSSProperty_animation_play_state, &nsStyleDisplay::mAnimationPlayStateCount }, { eCSSProperty_animation_iteration_count, &nsStyleDisplay::mAnimationIterationCountCount }, }; // Information about each transition or animation property that changes // during ComputeDisplayData. struct TransitionPropData { const nsCSSValueList *list; nsCSSUnit unit; uint32_t num; }; static uint32_t CountTransitionProps(const TransitionPropInfo* aInfo, TransitionPropData* aData, size_t aLength, nsStyleDisplay* aDisplay, const nsStyleDisplay* aParentDisplay, const nsRuleData* aRuleData, RuleNodeCacheConditions& aConditions) { // The four transition properties or eight animation properties are // stored in nsCSSDisplay in a single array for all properties. The // number of transitions is equal to the number of items in the // longest property's value. Properties that have fewer values than // the longest are filled in by repeating the list. However, this // repetition does not extend the computed value of that particular // property (for purposes of inheritance, or, in our code, for when // other properties are overridden by a more specific rule). // But actually, since the spec isn't clear yet, we'll fully compute // all of them (so we can switch easily later), but only care about // the ones up to the number of items for 'transition-property', per // http://lists.w3.org/Archives/Public/www-style/2009Aug/0109.html . // Transitions are difficult to handle correctly because of this. For // example, we need to handle scenarios such as: // * a more general rule specifies transition-property: a, b, c; // * a more specific rule overrides as transition-property: d; // // If only the general rule applied, we would fill in the extra // properties (duration, delay, etc) with initial values to create 3 // fully-specified transitions. But when the more specific rule // applies, we should only create a single transition. In order to do // this we need to remember which properties were explicitly specified // and which ones were just filled in with initial values to get a // fully-specified transition, which we do by remembering the number // of values for each property. uint32_t numTransitions = 0; for (size_t i = 0; i < aLength; ++i) { const TransitionPropInfo& info = aInfo[i]; TransitionPropData& data = aData[i]; // cache whether any of the properties are specified as 'inherit' so // we can use it below const nsCSSValue& value = *aRuleData->ValueFor(info.property); data.unit = value.GetUnit(); data.list = (value.GetUnit() == eCSSUnit_List || value.GetUnit() == eCSSUnit_ListDep) ? value.GetListValue() : nullptr; // General algorithm to determine how many total transitions we need // to build. For each property: // - if there is no value specified in for the property in // displayData, use the values from the start struct, but only if // they were explicitly specified // - if there is a value specified for the property in displayData: // - if the value is 'inherit', count the number of values for // that property are specified by the parent, but only those // that were explicitly specified // - otherwise, count the number of values specified in displayData // calculate number of elements if (data.unit == eCSSUnit_Inherit) { data.num = aParentDisplay->*(info.sdCount); aConditions.SetUncacheable(); } else if (data.list) { data.num = ListLength(data.list); } else { data.num = aDisplay->*(info.sdCount); } if (data.num > numTransitions) numTransitions = data.num; } return numTransitions; } /* static */ void nsRuleNode::ComputeTimingFunction(const nsCSSValue& aValue, nsTimingFunction& aResult) { switch (aValue.GetUnit()) { case eCSSUnit_Enumerated: aResult = nsTimingFunction(aValue.GetIntValue()); break; case eCSSUnit_Cubic_Bezier: { nsCSSValue::Array* array = aValue.GetArrayValue(); NS_ASSERTION(array && array->Count() == 4, "Need 4 control points"); aResult = nsTimingFunction(array->Item(0).GetFloatValue(), array->Item(1).GetFloatValue(), array->Item(2).GetFloatValue(), array->Item(3).GetFloatValue()); } break; case eCSSUnit_Steps: { nsCSSValue::Array* array = aValue.GetArrayValue(); NS_ASSERTION(array && array->Count() == 2, "Need 2 items"); NS_ASSERTION(array->Item(0).GetUnit() == eCSSUnit_Integer, "unexpected first value"); NS_ASSERTION(array->Item(1).GetUnit() == eCSSUnit_Enumerated && (array->Item(1).GetIntValue() == NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START || array->Item(1).GetIntValue() == NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_END || array->Item(1).GetIntValue() == -1), "unexpected second value"); nsTimingFunction::Type type = (array->Item(1).GetIntValue() == NS_STYLE_TRANSITION_TIMING_FUNCTION_STEP_START) ? nsTimingFunction::Type::StepStart : nsTimingFunction::Type::StepEnd; aResult = nsTimingFunction(type, array->Item(0).GetIntValue()); } break; default: NS_NOTREACHED("Invalid transition property unit"); } } static uint8_t GetWillChangeBitFieldFromPropFlags(const nsCSSPropertyID& aProp) { uint8_t willChangeBitField = 0; if (nsCSSProps::PropHasFlags(aProp, CSS_PROPERTY_CREATES_STACKING_CONTEXT)) { willChangeBitField |= NS_STYLE_WILL_CHANGE_STACKING_CONTEXT; } if (nsCSSProps::PropHasFlags(aProp, CSS_PROPERTY_FIXPOS_CB)) { willChangeBitField |= NS_STYLE_WILL_CHANGE_FIXPOS_CB; } if (nsCSSProps::PropHasFlags(aProp, CSS_PROPERTY_ABSPOS_CB)) { willChangeBitField |= NS_STYLE_WILL_CHANGE_ABSPOS_CB; } return willChangeBitField; } const void* nsRuleNode::ComputeDisplayData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Display, display, parentDisplay) // We may have ended up with aStartStruct's values of mDisplay and // mFloat, but those may not be correct if our style data overrides // its position or float properties. Reset to mOriginalDisplay and // mOriginalFloat; if it turns out we still need the display/floats // adjustments, we'll do them below. display->mDisplay = display->mOriginalDisplay; display->mFloat = display->mOriginalFloat; // Each property's index in this array must match its index in the // const array |transitionPropInfo| above. TransitionPropData transitionPropData[4]; TransitionPropData& delay = transitionPropData[0]; TransitionPropData& duration = transitionPropData[1]; TransitionPropData& property = transitionPropData[2]; TransitionPropData& timingFunction = transitionPropData[3]; #define FOR_ALL_TRANSITION_PROPS(var_) \ for (uint32_t var_ = 0; var_ < 4; ++var_) // CSS Transitions uint32_t numTransitions = CountTransitionProps(transitionPropInfo, transitionPropData, ArrayLength(transitionPropData), display, parentDisplay, aRuleData, conditions); display->mTransitions.SetLengthNonZero(numTransitions); FOR_ALL_TRANSITION_PROPS(p) { const TransitionPropInfo& i = transitionPropInfo[p]; TransitionPropData& d = transitionPropData[p]; display->*(i.sdCount) = d.num; } // Fill in the transitions we just allocated with the appropriate values. for (uint32_t i = 0; i < numTransitions; ++i) { StyleTransition *transition = &display->mTransitions[i]; if (i >= delay.num) { MOZ_ASSERT(delay.num, "delay.num must be greater than 0"); transition->SetDelay(display->mTransitions[i % delay.num].GetDelay()); } else if (delay.unit == eCSSUnit_Inherit) { // FIXME (Bug 522599) (for all transition properties): write a test that // detects when this was wrong for i >= delay.num if parent had // count for this property not equal to length MOZ_ASSERT(i < parentDisplay->mTransitionDelayCount, "delay.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); transition->SetDelay(parentDisplay->mTransitions[i].GetDelay()); } else if (delay.unit == eCSSUnit_Initial || delay.unit == eCSSUnit_Unset) { transition->SetDelay(0.0); } else if (delay.list) { switch (delay.list->mValue.GetUnit()) { case eCSSUnit_Seconds: transition->SetDelay(PR_MSEC_PER_SEC * delay.list->mValue.GetFloatValue()); break; case eCSSUnit_Milliseconds: transition->SetDelay(delay.list->mValue.GetFloatValue()); break; default: NS_NOTREACHED("Invalid delay unit"); } } if (i >= duration.num) { MOZ_ASSERT(duration.num, "duration.num must be greater than 0"); transition->SetDuration( display->mTransitions[i % duration.num].GetDuration()); } else if (duration.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mTransitionDurationCount, "duration.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); transition->SetDuration(parentDisplay->mTransitions[i].GetDuration()); } else if (duration.unit == eCSSUnit_Initial || duration.unit == eCSSUnit_Unset) { transition->SetDuration(0.0); } else if (duration.list) { switch (duration.list->mValue.GetUnit()) { case eCSSUnit_Seconds: transition->SetDuration(PR_MSEC_PER_SEC * duration.list->mValue.GetFloatValue()); break; case eCSSUnit_Milliseconds: transition->SetDuration(duration.list->mValue.GetFloatValue()); break; default: NS_NOTREACHED("Invalid duration unit"); } } if (i >= property.num) { MOZ_ASSERT(property.num, "property.num must be greater than 0"); transition->CopyPropertyFrom(display->mTransitions[i % property.num]); } else if (property.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mTransitionPropertyCount, "property.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); transition->CopyPropertyFrom(parentDisplay->mTransitions[i]); } else if (property.unit == eCSSUnit_Initial || property.unit == eCSSUnit_Unset) { transition->SetProperty(eCSSPropertyExtra_all_properties); } else if (property.unit == eCSSUnit_None) { transition->SetProperty(eCSSPropertyExtra_no_properties); } else if (property.list) { const nsCSSValue &val = property.list->mValue; if (val.GetUnit() == eCSSUnit_Ident) { nsDependentString propertyStr(property.list->mValue.GetStringBufferValue()); nsCSSPropertyID prop = nsCSSProps::LookupProperty(propertyStr, CSSEnabledState::eForAllContent); if (prop == eCSSProperty_UNKNOWN || prop == eCSSPropertyExtra_variable) { transition->SetUnknownProperty(prop, propertyStr); } else { transition->SetProperty(prop); } } else { MOZ_ASSERT(val.GetUnit() == eCSSUnit_All, "Invalid transition property unit"); transition->SetProperty(eCSSPropertyExtra_all_properties); } } if (i >= timingFunction.num) { MOZ_ASSERT(timingFunction.num, "timingFunction.num must be greater than 0"); transition->SetTimingFunction( display->mTransitions[i % timingFunction.num].GetTimingFunction()); } else if (timingFunction.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mTransitionTimingFunctionCount, "timingFunction.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); transition->SetTimingFunction( parentDisplay->mTransitions[i].GetTimingFunction()); } else if (timingFunction.unit == eCSSUnit_Initial || timingFunction.unit == eCSSUnit_Unset) { transition->SetTimingFunction( nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE)); } else if (timingFunction.list) { ComputeTimingFunction(timingFunction.list->mValue, transition->TimingFunctionSlot()); } FOR_ALL_TRANSITION_PROPS(p) { const TransitionPropInfo& info = transitionPropInfo[p]; TransitionPropData& d = transitionPropData[p]; // if we're at the end of the list, start at the beginning and repeat // until we're out of transitions to populate if (d.list) { d.list = d.list->mNext ? d.list->mNext : aRuleData->ValueFor(info.property)->GetListValue(); } } } // Each property's index in this array must match its index in the // const array |animationPropInfo| above. TransitionPropData animationPropData[8]; TransitionPropData& animDelay = animationPropData[0]; TransitionPropData& animDuration = animationPropData[1]; TransitionPropData& animName = animationPropData[2]; TransitionPropData& animTimingFunction = animationPropData[3]; TransitionPropData& animDirection = animationPropData[4]; TransitionPropData& animFillMode = animationPropData[5]; TransitionPropData& animPlayState = animationPropData[6]; TransitionPropData& animIterationCount = animationPropData[7]; #define FOR_ALL_ANIMATION_PROPS(var_) \ for (uint32_t var_ = 0; var_ < 8; ++var_) // CSS Animations. uint32_t numAnimations = CountTransitionProps(animationPropInfo, animationPropData, ArrayLength(animationPropData), display, parentDisplay, aRuleData, conditions); display->mAnimations.SetLengthNonZero(numAnimations); FOR_ALL_ANIMATION_PROPS(p) { const TransitionPropInfo& i = animationPropInfo[p]; TransitionPropData& d = animationPropData[p]; display->*(i.sdCount) = d.num; } // Fill in the animations we just allocated with the appropriate values. for (uint32_t i = 0; i < numAnimations; ++i) { StyleAnimation *animation = &display->mAnimations[i]; if (i >= animDelay.num) { MOZ_ASSERT(animDelay.num, "animDelay.num must be greater than 0"); animation->SetDelay(display->mAnimations[i % animDelay.num].GetDelay()); } else if (animDelay.unit == eCSSUnit_Inherit) { // FIXME (Bug 522599) (for all animation properties): write a test that // detects when this was wrong for i >= animDelay.num if parent had // count for this property not equal to length MOZ_ASSERT(i < parentDisplay->mAnimationDelayCount, "animDelay.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetDelay(parentDisplay->mAnimations[i].GetDelay()); } else if (animDelay.unit == eCSSUnit_Initial || animDelay.unit == eCSSUnit_Unset) { animation->SetDelay(0.0); } else if (animDelay.list) { switch (animDelay.list->mValue.GetUnit()) { case eCSSUnit_Seconds: animation->SetDelay(PR_MSEC_PER_SEC * animDelay.list->mValue.GetFloatValue()); break; case eCSSUnit_Milliseconds: animation->SetDelay(animDelay.list->mValue.GetFloatValue()); break; default: NS_NOTREACHED("Invalid delay unit"); } } if (i >= animDuration.num) { MOZ_ASSERT(animDuration.num, "animDuration.num must be greater than 0"); animation->SetDuration( display->mAnimations[i % animDuration.num].GetDuration()); } else if (animDuration.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mAnimationDurationCount, "animDuration.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetDuration(parentDisplay->mAnimations[i].GetDuration()); } else if (animDuration.unit == eCSSUnit_Initial || animDuration.unit == eCSSUnit_Unset) { animation->SetDuration(0.0); } else if (animDuration.list) { switch (animDuration.list->mValue.GetUnit()) { case eCSSUnit_Seconds: animation->SetDuration(PR_MSEC_PER_SEC * animDuration.list->mValue.GetFloatValue()); break; case eCSSUnit_Milliseconds: animation->SetDuration(animDuration.list->mValue.GetFloatValue()); break; default: NS_NOTREACHED("Invalid duration unit"); } } if (i >= animName.num) { MOZ_ASSERT(animName.num, "animName.num must be greater than 0"); animation->SetName(display->mAnimations[i % animName.num].GetName()); } else if (animName.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mAnimationNameCount, "animName.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetName(parentDisplay->mAnimations[i].GetName()); } else if (animName.unit == eCSSUnit_Initial || animName.unit == eCSSUnit_Unset) { animation->SetName(EmptyString()); } else if (animName.list) { switch (animName.list->mValue.GetUnit()) { case eCSSUnit_Ident: { nsDependentString nameStr(animName.list->mValue.GetStringBufferValue()); animation->SetName(nameStr); break; } case eCSSUnit_None: { animation->SetName(EmptyString()); break; } default: MOZ_ASSERT(false, "Invalid animation-name unit"); } } if (i >= animTimingFunction.num) { MOZ_ASSERT(animTimingFunction.num, "animTimingFunction.num must be greater than 0"); animation->SetTimingFunction( display->mAnimations[i % animTimingFunction.num].GetTimingFunction()); } else if (animTimingFunction.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mAnimationTimingFunctionCount, "animTimingFunction.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetTimingFunction( parentDisplay->mAnimations[i].GetTimingFunction()); } else if (animTimingFunction.unit == eCSSUnit_Initial || animTimingFunction.unit == eCSSUnit_Unset) { animation->SetTimingFunction( nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE)); } else if (animTimingFunction.list) { ComputeTimingFunction(animTimingFunction.list->mValue, animation->TimingFunctionSlot()); } if (i >= animDirection.num) { MOZ_ASSERT(animDirection.num, "animDirection.num must be greater than 0"); animation->SetDirection(display->mAnimations[i % animDirection.num].GetDirection()); } else if (animDirection.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mAnimationDirectionCount, "animDirection.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetDirection(parentDisplay->mAnimations[i].GetDirection()); } else if (animDirection.unit == eCSSUnit_Initial || animDirection.unit == eCSSUnit_Unset) { animation->SetDirection(dom::PlaybackDirection::Normal); } else if (animDirection.list) { MOZ_ASSERT(animDirection.list->mValue.GetUnit() == eCSSUnit_Enumerated, "Invalid animation-direction unit"); animation->SetDirection( static_cast<dom::PlaybackDirection>(animDirection.list->mValue.GetIntValue())); } if (i >= animFillMode.num) { MOZ_ASSERT(animFillMode.num, "animFillMode.num must be greater than 0"); animation->SetFillMode(display->mAnimations[i % animFillMode.num].GetFillMode()); } else if (animFillMode.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mAnimationFillModeCount, "animFillMode.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetFillMode(parentDisplay->mAnimations[i].GetFillMode()); } else if (animFillMode.unit == eCSSUnit_Initial || animFillMode.unit == eCSSUnit_Unset) { animation->SetFillMode(dom::FillMode::None); } else if (animFillMode.list) { MOZ_ASSERT(animFillMode.list->mValue.GetUnit() == eCSSUnit_Enumerated, "Invalid animation-fill-mode unit"); animation->SetFillMode( static_cast<dom::FillMode>(animFillMode.list->mValue.GetIntValue())); } if (i >= animPlayState.num) { MOZ_ASSERT(animPlayState.num, "animPlayState.num must be greater than 0"); animation->SetPlayState(display->mAnimations[i % animPlayState.num].GetPlayState()); } else if (animPlayState.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mAnimationPlayStateCount, "animPlayState.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetPlayState(parentDisplay->mAnimations[i].GetPlayState()); } else if (animPlayState.unit == eCSSUnit_Initial || animPlayState.unit == eCSSUnit_Unset) { animation->SetPlayState(NS_STYLE_ANIMATION_PLAY_STATE_RUNNING); } else if (animPlayState.list) { MOZ_ASSERT(animPlayState.list->mValue.GetUnit() == eCSSUnit_Enumerated, "Invalid animation-play-state unit"); animation->SetPlayState(animPlayState.list->mValue.GetIntValue()); } if (i >= animIterationCount.num) { MOZ_ASSERT(animIterationCount.num, "animIterationCount.num must be greater than 0"); animation->SetIterationCount(display->mAnimations[i % animIterationCount.num].GetIterationCount()); } else if (animIterationCount.unit == eCSSUnit_Inherit) { MOZ_ASSERT(i < parentDisplay->mAnimationIterationCountCount, "animIterationCount.num computed incorrectly"); MOZ_ASSERT(!conditions.Cacheable(), "should have made conditions.Cacheable() false above"); animation->SetIterationCount(parentDisplay->mAnimations[i].GetIterationCount()); } else if (animIterationCount.unit == eCSSUnit_Initial || animIterationCount.unit == eCSSUnit_Unset) { animation->SetIterationCount(1.0f); } else if (animIterationCount.list) { switch (animIterationCount.list->mValue.GetUnit()) { case eCSSUnit_Enumerated: MOZ_ASSERT(animIterationCount.list->mValue.GetIntValue() == NS_STYLE_ANIMATION_ITERATION_COUNT_INFINITE, "unexpected value"); animation->SetIterationCount(NS_IEEEPositiveInfinity()); break; case eCSSUnit_Number: animation->SetIterationCount( animIterationCount.list->mValue.GetFloatValue()); break; default: MOZ_ASSERT(false, "unexpected animation-iteration-count unit"); } } FOR_ALL_ANIMATION_PROPS(p) { const TransitionPropInfo& info = animationPropInfo[p]; TransitionPropData& d = animationPropData[p]; // if we're at the end of the list, start at the beginning and repeat // until we're out of animations to populate if (d.list) { d.list = d.list->mNext ? d.list->mNext : aRuleData->ValueFor(info.property)->GetListValue(); } } } // display: enum, inherit, initial SetValue(*aRuleData->ValueForDisplay(), display->mDisplay, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mDisplay, StyleDisplay::Inline); // contain: none, enum, inherit, initial SetValue(*aRuleData->ValueForContain(), display->mContain, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mContain, NS_STYLE_CONTAIN_NONE, Unused, NS_STYLE_CONTAIN_NONE, Unused, Unused); // scroll-behavior: enum, inherit, initial SetValue(*aRuleData->ValueForScrollBehavior(), display->mScrollBehavior, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mScrollBehavior, NS_STYLE_SCROLL_BEHAVIOR_AUTO); // scroll-snap-type-x: none, enum, inherit, initial SetValue(*aRuleData->ValueForScrollSnapTypeX(), display->mScrollSnapTypeX, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mScrollSnapTypeX, NS_STYLE_SCROLL_SNAP_TYPE_NONE); // scroll-snap-type-y: none, enum, inherit, initial SetValue(*aRuleData->ValueForScrollSnapTypeY(), display->mScrollSnapTypeY, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mScrollSnapTypeY, NS_STYLE_SCROLL_SNAP_TYPE_NONE); // scroll-snap-points-x: none, inherit, initial const nsCSSValue& scrollSnapPointsX = *aRuleData->ValueForScrollSnapPointsX(); switch (scrollSnapPointsX.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: display->mScrollSnapPointsX.SetNoneValue(); break; case eCSSUnit_Inherit: display->mScrollSnapPointsX = parentDisplay->mScrollSnapPointsX; conditions.SetUncacheable(); break; case eCSSUnit_Function: { nsCSSValue::Array* func = scrollSnapPointsX.GetArrayValue(); NS_ASSERTION(func->Item(0).GetKeywordValue() == eCSSKeyword_repeat, "Expected repeat(), got another function name"); nsStyleCoord coord; if (SetCoord(func->Item(1), coord, nsStyleCoord(), SETCOORD_LP | SETCOORD_STORE_CALC | SETCOORD_CALC_CLAMP_NONNEGATIVE, aContext, mPresContext, conditions)) { NS_ASSERTION(coord.GetUnit() == eStyleUnit_Coord || coord.GetUnit() == eStyleUnit_Percent || coord.GetUnit() == eStyleUnit_Calc, "unexpected unit"); display->mScrollSnapPointsX = coord; } break; } default: NS_NOTREACHED("unexpected unit"); } // scroll-snap-points-y: none, inherit, initial const nsCSSValue& scrollSnapPointsY = *aRuleData->ValueForScrollSnapPointsY(); switch (scrollSnapPointsY.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: display->mScrollSnapPointsY.SetNoneValue(); break; case eCSSUnit_Inherit: display->mScrollSnapPointsY = parentDisplay->mScrollSnapPointsY; conditions.SetUncacheable(); break; case eCSSUnit_Function: { nsCSSValue::Array* func = scrollSnapPointsY.GetArrayValue(); NS_ASSERTION(func->Item(0).GetKeywordValue() == eCSSKeyword_repeat, "Expected repeat(), got another function name"); nsStyleCoord coord; if (SetCoord(func->Item(1), coord, nsStyleCoord(), SETCOORD_LP | SETCOORD_STORE_CALC | SETCOORD_CALC_CLAMP_NONNEGATIVE, aContext, mPresContext, conditions)) { NS_ASSERTION(coord.GetUnit() == eStyleUnit_Coord || coord.GetUnit() == eStyleUnit_Percent || coord.GetUnit() == eStyleUnit_Calc, "unexpected unit"); display->mScrollSnapPointsY = coord; } break; } default: NS_NOTREACHED("unexpected unit"); } // scroll-snap-destination: inherit, initial const nsCSSValue& snapDestination = *aRuleData->ValueForScrollSnapDestination(); switch (snapDestination.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_Unset: display->mScrollSnapDestination.SetInitialZeroValues(); break; case eCSSUnit_Inherit: display->mScrollSnapDestination = parentDisplay->mScrollSnapDestination; conditions.SetUncacheable(); break; default: { ComputePositionValue(aContext, snapDestination, display->mScrollSnapDestination, conditions); } } // scroll-snap-coordinate: none, inherit, initial const nsCSSValue& snapCoordinate = *aRuleData->ValueForScrollSnapCoordinate(); switch (snapCoordinate.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: // Unset and Initial is none, indicated by an empty array display->mScrollSnapCoordinate.Clear(); break; case eCSSUnit_Inherit: display->mScrollSnapCoordinate = parentDisplay->mScrollSnapCoordinate; conditions.SetUncacheable(); break; case eCSSUnit_List: { display->mScrollSnapCoordinate.Clear(); const nsCSSValueList* item = snapCoordinate.GetListValue(); do { NS_ASSERTION(item->mValue.GetUnit() != eCSSUnit_Null && item->mValue.GetUnit() != eCSSUnit_Inherit && item->mValue.GetUnit() != eCSSUnit_Initial && item->mValue.GetUnit() != eCSSUnit_Unset, "unexpected unit"); Position* pos = display->mScrollSnapCoordinate.AppendElement(); ComputePositionValue(aContext, item->mValue, *pos, conditions); item = item->mNext; } while(item); break; } default: NS_NOTREACHED("unexpected unit"); } // isolation: enum, inherit, initial SetValue(*aRuleData->ValueForIsolation(), display->mIsolation, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mIsolation, NS_STYLE_ISOLATION_AUTO); // -moz-top-layer: enum, inherit, initial SetValue(*aRuleData->ValueForTopLayer(), display->mTopLayer, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mTopLayer, NS_STYLE_TOP_LAYER_NONE); // Backup original display value for calculation of a hypothetical // box (CSS2 10.6.4/10.6.5), in addition to getting our style data right later. // See ReflowInput::CalculateHypotheticalBox display->mOriginalDisplay = display->mDisplay; // appearance: enum, inherit, initial SetValue(*aRuleData->ValueForAppearance(), display->mAppearance, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mAppearance, NS_THEME_NONE); // binding: url, none, inherit const nsCSSValue* bindingValue = aRuleData->ValueForBinding(); if (eCSSUnit_URL == bindingValue->GetUnit()) { mozilla::css::URLValue* url = bindingValue->GetURLStructValue(); NS_ASSERTION(url, "What's going on here?"); if (MOZ_LIKELY(url->GetURI())) { display->mBinding = url; } else { display->mBinding = nullptr; } } else if (eCSSUnit_None == bindingValue->GetUnit() || eCSSUnit_Initial == bindingValue->GetUnit() || eCSSUnit_Unset == bindingValue->GetUnit()) { display->mBinding = nullptr; } else if (eCSSUnit_Inherit == bindingValue->GetUnit()) { conditions.SetUncacheable(); display->mBinding = parentDisplay->mBinding; } // position: enum, inherit, initial SetValue(*aRuleData->ValueForPosition(), display->mPosition, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mPosition, NS_STYLE_POSITION_STATIC); // If an element is put in the top layer, while it is not absolutely // positioned, the position value should be computed to 'absolute' per // the Fullscreen API spec. if (display->mTopLayer != NS_STYLE_TOP_LAYER_NONE && !display->IsAbsolutelyPositionedStyle()) { display->mPosition = NS_STYLE_POSITION_ABSOLUTE; // We cannot cache this struct because otherwise it may be used as // an aStartStruct for some other elements. conditions.SetUncacheable(); } // clear: enum, inherit, initial SetValue(*aRuleData->ValueForClear(), display->mBreakType, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mBreakType, StyleClear::None); // temp fix for bug 24000 // Map 'auto' and 'avoid' to false, and 'always', 'left', and // 'right' to true. // "A conforming user agent may interpret the values 'left' and // 'right' as 'always'." - CSS2.1, section 13.3.1 const nsCSSValue* breakBeforeValue = aRuleData->ValueForPageBreakBefore(); if (eCSSUnit_Enumerated == breakBeforeValue->GetUnit()) { display->mBreakBefore = (NS_STYLE_PAGE_BREAK_AVOID != breakBeforeValue->GetIntValue() && NS_STYLE_PAGE_BREAK_AUTO != breakBeforeValue->GetIntValue()); } else if (eCSSUnit_Initial == breakBeforeValue->GetUnit() || eCSSUnit_Unset == breakBeforeValue->GetUnit()) { display->mBreakBefore = false; } else if (eCSSUnit_Inherit == breakBeforeValue->GetUnit()) { conditions.SetUncacheable(); display->mBreakBefore = parentDisplay->mBreakBefore; } const nsCSSValue* breakAfterValue = aRuleData->ValueForPageBreakAfter(); if (eCSSUnit_Enumerated == breakAfterValue->GetUnit()) { display->mBreakAfter = (NS_STYLE_PAGE_BREAK_AVOID != breakAfterValue->GetIntValue() && NS_STYLE_PAGE_BREAK_AUTO != breakAfterValue->GetIntValue()); } else if (eCSSUnit_Initial == breakAfterValue->GetUnit() || eCSSUnit_Unset == breakAfterValue->GetUnit()) { display->mBreakAfter = false; } else if (eCSSUnit_Inherit == breakAfterValue->GetUnit()) { conditions.SetUncacheable(); display->mBreakAfter = parentDisplay->mBreakAfter; } // end temp fix // page-break-inside: enum, inherit, initial SetValue(*aRuleData->ValueForPageBreakInside(), display->mBreakInside, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mBreakInside, NS_STYLE_PAGE_BREAK_AUTO); // touch-action: none, auto, enum, inherit, initial SetValue(*aRuleData->ValueForTouchAction(), display->mTouchAction, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mTouchAction, /* initial */ NS_STYLE_TOUCH_ACTION_AUTO, /* auto */ NS_STYLE_TOUCH_ACTION_AUTO, /* none */ NS_STYLE_TOUCH_ACTION_NONE, Unused, Unused); // float: enum, inherit, initial SetValue(*aRuleData->ValueForFloat(), display->mFloat, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mFloat, StyleFloat::None); // Save mFloat in mOriginalFloat in case we need it later display->mOriginalFloat = display->mFloat; // overflow-x: enum, inherit, initial SetValue(*aRuleData->ValueForOverflowX(), display->mOverflowX, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mOverflowX, NS_STYLE_OVERFLOW_VISIBLE); // overflow-y: enum, inherit, initial SetValue(*aRuleData->ValueForOverflowY(), display->mOverflowY, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mOverflowY, NS_STYLE_OVERFLOW_VISIBLE); // CSS3 overflow-x and overflow-y require some fixup as well in some // cases. NS_STYLE_OVERFLOW_VISIBLE and NS_STYLE_OVERFLOW_CLIP are // meaningful only when used in both dimensions. if (display->mOverflowX != display->mOverflowY && (display->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE || display->mOverflowX == NS_STYLE_OVERFLOW_CLIP || display->mOverflowY == NS_STYLE_OVERFLOW_VISIBLE || display->mOverflowY == NS_STYLE_OVERFLOW_CLIP)) { // We can't store in the rule tree since a more specific rule might // change these conditions. conditions.SetUncacheable(); // NS_STYLE_OVERFLOW_CLIP is a deprecated value, so if it's specified // in only one dimension, convert it to NS_STYLE_OVERFLOW_HIDDEN. if (display->mOverflowX == NS_STYLE_OVERFLOW_CLIP) display->mOverflowX = NS_STYLE_OVERFLOW_HIDDEN; if (display->mOverflowY == NS_STYLE_OVERFLOW_CLIP) display->mOverflowY = NS_STYLE_OVERFLOW_HIDDEN; // If 'visible' is specified but doesn't match the other dimension, it // turns into 'auto'. if (display->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE) display->mOverflowX = NS_STYLE_OVERFLOW_AUTO; if (display->mOverflowY == NS_STYLE_OVERFLOW_VISIBLE) display->mOverflowY = NS_STYLE_OVERFLOW_AUTO; } // When 'contain: paint', update overflow from 'visible' to 'clip'. if (display->IsContainPaint()) { // XXX This actually sets overflow-[x|y] to -moz-hidden-unscrollable. if (display->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE) { // This uncacheability (and the one below) could be fixed by adding // mOriginalOverflowX and mOriginalOverflowY fields, if necessary. display->mOverflowX = NS_STYLE_OVERFLOW_CLIP; conditions.SetUncacheable(); } if (display->mOverflowY == NS_STYLE_OVERFLOW_VISIBLE) { display->mOverflowY = NS_STYLE_OVERFLOW_CLIP; conditions.SetUncacheable(); } } SetValue(*aRuleData->ValueForOverflowClipBox(), display->mOverflowClipBox, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mOverflowClipBox, NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX); SetValue(*aRuleData->ValueForResize(), display->mResize, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mResize, NS_STYLE_RESIZE_NONE); if (display->mDisplay != StyleDisplay::None) { // CSS2 9.7 specifies display type corrections dealing with 'float' // and 'position'. Since generated content can't be floated or // positioned, we can deal with it here. nsIAtom* pseudo = aContext->GetPseudo(); if (pseudo && display->mDisplay == StyleDisplay::Contents) { // We don't want to create frames for anonymous content using a parent // frame that is for content above the root of the anon tree. // (XXX what we really should check here is not GetPseudo() but if there's // a 'content' property value that implies anon content but we can't // check that here since that's a different struct(?)) // We might get display:contents to work for CSS_PSEUDO_ELEMENT_CONTAINS_ELEMENTS // pseudos (:first-letter etc) in the future, but those have a lot of // special handling in frame construction so they are also unsupported // for now. display->mOriginalDisplay = display->mDisplay = StyleDisplay::Inline; conditions.SetUncacheable(); } // Inherit a <fieldset> grid/flex display type into its anon content frame. if (pseudo == nsCSSAnonBoxes::fieldsetContent) { MOZ_ASSERT(display->mDisplay == StyleDisplay::Block, "forms.css should have set 'display:block'"); switch (parentDisplay->mDisplay) { case StyleDisplay::Grid: case StyleDisplay::InlineGrid: display->mDisplay = StyleDisplay::Grid; conditions.SetUncacheable(); break; case StyleDisplay::Flex: case StyleDisplay::InlineFlex: display->mDisplay = StyleDisplay::Flex; conditions.SetUncacheable(); break; default: break; // Do nothing } } if (nsCSSPseudoElements::firstLetter == pseudo) { // a non-floating first-letter must be inline // XXX this fix can go away once bug 103189 is fixed correctly // Note that we reset mOriginalDisplay to enforce the invariant that it equals mDisplay if we're not positioned or floating. display->mOriginalDisplay = display->mDisplay = StyleDisplay::Inline; // We can't cache the data in the rule tree since if a more specific // rule has 'float: left' we'll end up with the wrong 'display' // property. conditions.SetUncacheable(); } if (display->IsAbsolutelyPositionedStyle()) { // 1) if position is 'absolute' or 'fixed' then display must be // block-level and float must be 'none' EnsureBlockDisplay(display->mDisplay); display->mFloat = StyleFloat::None; // Note that it's OK to cache this struct in the ruletree // because it's fine as-is for any style context that points to // it directly, and any use of it as aStartStruct (e.g. if a // more specific rule sets "position: static") will use // mOriginalDisplay and mOriginalFloat, which we have carefully // not changed. } else if (display->mFloat != StyleFloat::None) { // 2) if float is not none, and display is not none, then we must // set a block-level 'display' type per CSS2.1 section 9.7. EnsureBlockDisplay(display->mDisplay); // Note that it's OK to cache this struct in the ruletree // because it's fine as-is for any style context that points to // it directly, and any use of it as aStartStruct (e.g. if a // more specific rule sets "float: none") will use // mOriginalDisplay, which we have carefully not changed. } if (display->IsContainPaint()) { // An element with contain:paint or contain:layout needs to "be a // formatting context". For the purposes of the "display" property, that // just means we need to promote "display:inline" to "inline-block". // XXX We may also need to promote ruby display vals; see bug 1179349. // It's okay to cache this change in the rule tree for the same // reasons as floats in the previous condition. if (display->mDisplay == StyleDisplay::Inline) { display->mDisplay = StyleDisplay::InlineBlock; } } } /* Convert the nsCSSValueList into an nsTArray<nsTransformFunction *>. */ const nsCSSValue* transformValue = aRuleData->ValueForTransform(); switch (transformValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: display->mSpecifiedTransform = nullptr; break; case eCSSUnit_Inherit: display->mSpecifiedTransform = parentDisplay->mSpecifiedTransform; conditions.SetUncacheable(); break; case eCSSUnit_SharedList: { nsCSSValueSharedList* list = transformValue->GetSharedListValue(); nsCSSValueList* head = list->mHead; MOZ_ASSERT(head, "transform list must have at least one item"); // can get a _None in here from transform animation if (head->mValue.GetUnit() == eCSSUnit_None) { MOZ_ASSERT(head->mNext == nullptr, "none must be alone"); display->mSpecifiedTransform = nullptr; } else { display->mSpecifiedTransform = list; } break; } default: MOZ_ASSERT(false, "unrecognized transform unit"); } /* Convert the nsCSSValueList into a will-change bitfield for fast lookup */ const nsCSSValue* willChangeValue = aRuleData->ValueForWillChange(); switch (willChangeValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_List: case eCSSUnit_ListDep: { display->mWillChange.Clear(); display->mWillChangeBitField = 0; for (const nsCSSValueList* item = willChangeValue->GetListValue(); item; item = item->mNext) { if (item->mValue.UnitHasStringValue()) { nsAutoString buffer; item->mValue.GetStringValue(buffer); display->mWillChange.AppendElement(buffer); if (buffer.EqualsLiteral("transform")) { display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_TRANSFORM; } if (buffer.EqualsLiteral("opacity")) { display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_OPACITY; } if (buffer.EqualsLiteral("scroll-position")) { display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_SCROLL; } nsCSSPropertyID prop = nsCSSProps::LookupProperty(buffer, CSSEnabledState::eForAllContent); if (prop != eCSSProperty_UNKNOWN && prop != eCSSPropertyExtra_variable) { // If the property given is a shorthand, it indicates the expectation // for all the longhands the shorthand expands to. if (nsCSSProps::IsShorthand(prop)) { for (const nsCSSPropertyID* shorthands = nsCSSProps::SubpropertyEntryFor(prop); *shorthands != eCSSProperty_UNKNOWN; ++shorthands) { display->mWillChangeBitField |= GetWillChangeBitFieldFromPropFlags(*shorthands); } } else { display->mWillChangeBitField |= GetWillChangeBitFieldFromPropFlags(prop); } } } } break; } case eCSSUnit_Inherit: display->mWillChange = parentDisplay->mWillChange; display->mWillChangeBitField = parentDisplay->mWillChangeBitField; conditions.SetUncacheable(); break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_Auto: display->mWillChange.Clear(); display->mWillChangeBitField = 0; break; default: MOZ_ASSERT(false, "unrecognized will-change unit"); } // vertical-align: enum, length, percent, calc, inherit const nsCSSValue* verticalAlignValue = aRuleData->ValueForVerticalAlign(); if (!SetCoord(*verticalAlignValue, display->mVerticalAlign, parentDisplay->mVerticalAlign, SETCOORD_LPH | SETCOORD_ENUMERATED | SETCOORD_STORE_CALC, aContext, mPresContext, conditions)) { if (eCSSUnit_Initial == verticalAlignValue->GetUnit() || eCSSUnit_Unset == verticalAlignValue->GetUnit()) { display->mVerticalAlign.SetIntValue(NS_STYLE_VERTICAL_ALIGN_BASELINE, eStyleUnit_Enumerated); } } /* Convert -moz-transform-origin. */ const nsCSSValue* transformOriginValue = aRuleData->ValueForTransformOrigin(); if (transformOriginValue->GetUnit() != eCSSUnit_Null) { const nsCSSValue& valX = transformOriginValue->GetUnit() == eCSSUnit_Triplet ? transformOriginValue->GetTripletValue().mXValue : *transformOriginValue; const nsCSSValue& valY = transformOriginValue->GetUnit() == eCSSUnit_Triplet ? transformOriginValue->GetTripletValue().mYValue : *transformOriginValue; const nsCSSValue& valZ = transformOriginValue->GetUnit() == eCSSUnit_Triplet ? transformOriginValue->GetTripletValue().mZValue : *transformOriginValue; mozilla::DebugOnly<bool> cX = SetCoord(valX, display->mTransformOrigin[0], parentDisplay->mTransformOrigin[0], SETCOORD_LPH | SETCOORD_INITIAL_HALF | SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); mozilla::DebugOnly<bool> cY = SetCoord(valY, display->mTransformOrigin[1], parentDisplay->mTransformOrigin[1], SETCOORD_LPH | SETCOORD_INITIAL_HALF | SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); if (valZ.GetUnit() == eCSSUnit_Null) { // Null for the z component means a 0 translation, not // unspecified, as we have already checked the triplet // value for Null. display->mTransformOrigin[2].SetCoordValue(0); } else { mozilla::DebugOnly<bool> cZ = SetCoord(valZ, display->mTransformOrigin[2], parentDisplay->mTransformOrigin[2], SETCOORD_LH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); MOZ_ASSERT(cY == cZ, "changed one but not the other"); } MOZ_ASSERT(cX == cY, "changed one but not the other"); NS_ASSERTION(cX, "Malformed -moz-transform-origin parse!"); } const nsCSSValue* perspectiveOriginValue = aRuleData->ValueForPerspectiveOrigin(); if (perspectiveOriginValue->GetUnit() != eCSSUnit_Null) { mozilla::DebugOnly<bool> result = SetPairCoords(*perspectiveOriginValue, display->mPerspectiveOrigin[0], display->mPerspectiveOrigin[1], parentDisplay->mPerspectiveOrigin[0], parentDisplay->mPerspectiveOrigin[1], SETCOORD_LPH | SETCOORD_INITIAL_HALF | SETCOORD_BOX_POSITION | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); NS_ASSERTION(result, "Malformed -moz-perspective-origin parse!"); } SetCoord(*aRuleData->ValueForPerspective(), display->mChildPerspective, parentDisplay->mChildPerspective, SETCOORD_LAH | SETCOORD_INITIAL_NONE | SETCOORD_NONE | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); SetValue(*aRuleData->ValueForBackfaceVisibility(), display->mBackfaceVisibility, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mBackfaceVisibility, NS_STYLE_BACKFACE_VISIBILITY_VISIBLE); // transform-style: enum, inherit, initial SetValue(*aRuleData->ValueForTransformStyle(), display->mTransformStyle, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mTransformStyle, NS_STYLE_TRANSFORM_STYLE_FLAT); // transform-box: enum, inherit, initial SetValue(*aRuleData->ValueForTransformBox(), display->mTransformBox, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mTransformBox, NS_STYLE_TRANSFORM_BOX_BORDER_BOX); // orient: enum, inherit, initial SetValue(*aRuleData->ValueForOrient(), display->mOrient, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentDisplay->mOrient, StyleOrient::Inline); // shape-outside: none | [ <basic-shape> || <shape-box> ] | <image> const nsCSSValue* shapeOutsideValue = aRuleData->ValueForShapeOutside(); switch (shapeOutsideValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_None: case eCSSUnit_Initial: case eCSSUnit_Unset: display->mShapeOutside = StyleShapeOutside(); break; case eCSSUnit_Inherit: conditions.SetUncacheable(); display->mShapeOutside = parentDisplay->mShapeOutside; break; case eCSSUnit_URL: { display->mShapeOutside = StyleShapeOutside(); display->mShapeOutside.SetURL(shapeOutsideValue->GetURLStructValue()); break; } case eCSSUnit_Array: { display->mShapeOutside = StyleShapeOutside(); SetStyleShapeSourceToCSSValue(&display->mShapeOutside, shapeOutsideValue, aContext, mPresContext, conditions); break; } default: MOZ_ASSERT_UNREACHABLE("Unrecognized shape-outside unit!"); } COMPUTE_END_RESET(Display, display) } const void* nsRuleNode::ComputeVisibilityData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(Visibility, visibility, parentVisibility) // IMPORTANT: No properties in this struct have lengths in them. We // depend on this since CalcLengthWith can call StyleVisibility() // to get the language for resolving fonts! // direction: enum, inherit, initial SetValue(*aRuleData->ValueForDirection(), visibility->mDirection, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentVisibility->mDirection, (GET_BIDI_OPTION_DIRECTION(mPresContext->GetBidi()) == IBMBIDI_TEXTDIRECTION_RTL) ? NS_STYLE_DIRECTION_RTL : NS_STYLE_DIRECTION_LTR); // visibility: enum, inherit, initial SetValue(*aRuleData->ValueForVisibility(), visibility->mVisible, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentVisibility->mVisible, NS_STYLE_VISIBILITY_VISIBLE); // image-rendering: enum, inherit SetValue(*aRuleData->ValueForImageRendering(), visibility->mImageRendering, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentVisibility->mImageRendering, NS_STYLE_IMAGE_RENDERING_AUTO); // writing-mode: enum, inherit, initial SetValue(*aRuleData->ValueForWritingMode(), visibility->mWritingMode, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentVisibility->mWritingMode, NS_STYLE_WRITING_MODE_HORIZONTAL_TB); // text-orientation: enum, inherit, initial SetValue(*aRuleData->ValueForTextOrientation(), visibility->mTextOrientation, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentVisibility->mTextOrientation, NS_STYLE_TEXT_ORIENTATION_MIXED); // image-orientation: enum, inherit, initial const nsCSSValue* orientation = aRuleData->ValueForImageOrientation(); if (orientation->GetUnit() == eCSSUnit_Inherit || orientation->GetUnit() == eCSSUnit_Unset) { conditions.SetUncacheable(); visibility->mImageOrientation = parentVisibility->mImageOrientation; } else if (orientation->GetUnit() == eCSSUnit_Initial) { visibility->mImageOrientation = nsStyleImageOrientation(); } else if (orientation->IsAngularUnit()) { double angle = orientation->GetAngleValueInRadians(); visibility->mImageOrientation = nsStyleImageOrientation::CreateAsAngleAndFlip(angle, false); } else if (orientation->GetUnit() == eCSSUnit_Array) { const nsCSSValue::Array* array = orientation->GetArrayValue(); MOZ_ASSERT(array->Item(0).IsAngularUnit(), "First image-orientation value is not an angle"); MOZ_ASSERT(array->Item(1).GetUnit() == eCSSUnit_Enumerated && array->Item(1).GetIntValue() == NS_STYLE_IMAGE_ORIENTATION_FLIP, "Second image-orientation value is not 'flip'"); double angle = array->Item(0).GetAngleValueInRadians(); visibility->mImageOrientation = nsStyleImageOrientation::CreateAsAngleAndFlip(angle, true); } else if (orientation->GetUnit() == eCSSUnit_Enumerated) { switch (orientation->GetIntValue()) { case NS_STYLE_IMAGE_ORIENTATION_FLIP: visibility->mImageOrientation = nsStyleImageOrientation::CreateAsFlip(); break; case NS_STYLE_IMAGE_ORIENTATION_FROM_IMAGE: visibility->mImageOrientation = nsStyleImageOrientation::CreateAsFromImage(); break; default: NS_NOTREACHED("Invalid image-orientation enumerated value"); } } else { MOZ_ASSERT(orientation->GetUnit() == eCSSUnit_Null, "Should be null unit"); } SetValue(*aRuleData->ValueForColorAdjust(), visibility->mColorAdjust, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentVisibility->mColorAdjust, NS_STYLE_COLOR_ADJUST_ECONOMY); COMPUTE_END_INHERITED(Visibility, visibility) } const void* nsRuleNode::ComputeColorData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(Color, color, parentColor) // color: color, string, inherit // Special case for currentColor. According to CSS3, setting color to 'currentColor' // should behave as if it is inherited const nsCSSValue* colorValue = aRuleData->ValueForColor(); if ((colorValue->GetUnit() == eCSSUnit_EnumColor && colorValue->GetIntValue() == NS_COLOR_CURRENTCOLOR) || colorValue->GetUnit() == eCSSUnit_Unset) { color->mColor = parentColor->mColor; conditions.SetUncacheable(); } else if (colorValue->GetUnit() == eCSSUnit_Initial) { color->mColor = mPresContext->DefaultColor(); } else { SetColor(*colorValue, parentColor->mColor, mPresContext, aContext, color->mColor, conditions); } COMPUTE_END_INHERITED(Color, color) } // information about how to compute values for background-* properties template <class SpecifiedValueItem, class ComputedValueItem> struct BackgroundItemComputer { }; template <> struct BackgroundItemComputer<nsCSSValueList, uint8_t> { static void ComputeValue(nsStyleContext* aStyleContext, const nsCSSValueList* aSpecifiedValue, uint8_t& aComputedValue, RuleNodeCacheConditions& aConditions) { SetValue(aSpecifiedValue->mValue, aComputedValue, aConditions, SETVAL_ENUMERATED, uint8_t(0), 0); } }; template <> struct BackgroundItemComputer<nsCSSValuePairList, nsStyleImageLayers::Repeat> { static void ComputeValue(nsStyleContext* aStyleContext, const nsCSSValuePairList* aSpecifiedValue, nsStyleImageLayers::Repeat& aComputedValue, RuleNodeCacheConditions& aConditions) { NS_ASSERTION(aSpecifiedValue->mXValue.GetUnit() == eCSSUnit_Enumerated && (aSpecifiedValue->mYValue.GetUnit() == eCSSUnit_Enumerated || aSpecifiedValue->mYValue.GetUnit() == eCSSUnit_Null), "Invalid unit"); bool hasContraction = true; uint8_t value = aSpecifiedValue->mXValue.GetIntValue(); switch (value) { case NS_STYLE_IMAGELAYER_REPEAT_REPEAT_X: aComputedValue.mXRepeat = NS_STYLE_IMAGELAYER_REPEAT_REPEAT; aComputedValue.mYRepeat = NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT; break; case NS_STYLE_IMAGELAYER_REPEAT_REPEAT_Y: aComputedValue.mXRepeat = NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT; aComputedValue.mYRepeat = NS_STYLE_IMAGELAYER_REPEAT_REPEAT; break; default: NS_ASSERTION(value == NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT || value == NS_STYLE_IMAGELAYER_REPEAT_REPEAT || value == NS_STYLE_IMAGELAYER_REPEAT_SPACE || value == NS_STYLE_IMAGELAYER_REPEAT_ROUND, "Unexpected value"); aComputedValue.mXRepeat = value; hasContraction = false; break; } if (hasContraction) { NS_ASSERTION(aSpecifiedValue->mYValue.GetUnit() == eCSSUnit_Null, "Invalid unit."); return; } switch (aSpecifiedValue->mYValue.GetUnit()) { case eCSSUnit_Null: aComputedValue.mYRepeat = aComputedValue.mXRepeat; break; case eCSSUnit_Enumerated: value = aSpecifiedValue->mYValue.GetIntValue(); NS_ASSERTION(value == NS_STYLE_IMAGELAYER_REPEAT_NO_REPEAT || value == NS_STYLE_IMAGELAYER_REPEAT_REPEAT || value == NS_STYLE_IMAGELAYER_REPEAT_SPACE || value == NS_STYLE_IMAGELAYER_REPEAT_ROUND, "Unexpected value"); aComputedValue.mYRepeat = value; break; default: NS_NOTREACHED("Unexpected CSS value"); break; } } }; template <> struct BackgroundItemComputer<nsCSSValueList, nsStyleImage> { static void ComputeValue(nsStyleContext* aStyleContext, const nsCSSValueList* aSpecifiedValue, nsStyleImage& aComputedValue, RuleNodeCacheConditions& aConditions) { SetStyleImage(aStyleContext, aSpecifiedValue->mValue, aComputedValue, aConditions); } }; template <> struct BackgroundItemComputer<nsCSSValueList, RefPtr<css::URLValueData>> { static void ComputeValue(nsStyleContext* aStyleContext, const nsCSSValueList* aSpecifiedValue, RefPtr<css::URLValueData>& aComputedValue, RuleNodeCacheConditions& aConditions) { switch (aSpecifiedValue->mValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_URL: aComputedValue = aSpecifiedValue->mValue.GetURLStructValue(); break; case eCSSUnit_Image: aComputedValue = aSpecifiedValue->mValue.GetImageStructValue(); break; default: aComputedValue = nullptr; break; } } }; template <typename T> struct BackgroundItemComputer<nsCSSValueList, T> { typedef typename EnableIf<IsEnum<T>::value, T>::Type ComputedType; static void ComputeValue(nsStyleContext* aStyleContext, const nsCSSValueList* aSpecifiedValue, ComputedType& aComputedValue, RuleNodeCacheConditions& aConditions) { aComputedValue = static_cast<T>(aSpecifiedValue->mValue.GetIntValue()); } }; /* Helper function for ComputePositionValue. * This function computes a single PositionCoord from two nsCSSValue objects, * which represent an edge and an offset from that edge. */ static void ComputePositionCoord(nsStyleContext* aStyleContext, const nsCSSValue& aEdge, const nsCSSValue& aOffset, Position::Coord* aResult, RuleNodeCacheConditions& aConditions) { if (eCSSUnit_Percent == aOffset.GetUnit()) { aResult->mLength = 0; aResult->mPercent = aOffset.GetPercentValue(); aResult->mHasPercent = true; } else if (aOffset.IsLengthUnit()) { aResult->mLength = CalcLength(aOffset, aStyleContext, aStyleContext->PresContext(), aConditions); aResult->mPercent = 0.0f; aResult->mHasPercent = false; } else if (aOffset.IsCalcUnit()) { LengthPercentPairCalcOps ops(aStyleContext, aStyleContext->PresContext(), aConditions); nsRuleNode::ComputedCalc vals = ComputeCalc(aOffset, ops); aResult->mLength = vals.mLength; aResult->mPercent = vals.mPercent; aResult->mHasPercent = ops.mHasPercent; } else { aResult->mLength = 0; aResult->mPercent = 0.0f; aResult->mHasPercent = false; NS_ASSERTION(aOffset.GetUnit() == eCSSUnit_Null, "unexpected unit"); } if (eCSSUnit_Enumerated == aEdge.GetUnit()) { int sign; if (aEdge.GetIntValue() & (NS_STYLE_IMAGELAYER_POSITION_BOTTOM | NS_STYLE_IMAGELAYER_POSITION_RIGHT)) { sign = -1; } else { sign = 1; } aResult->mPercent = GetFloatFromBoxPosition(aEdge.GetIntValue()) + sign * aResult->mPercent; aResult->mLength = sign * aResult->mLength; aResult->mHasPercent = true; } else { NS_ASSERTION(eCSSUnit_Null == aEdge.GetUnit(), "unexpected unit"); } } /* Helper function to convert a CSS <position> specified value into its * computed-style form. */ static void ComputePositionValue(nsStyleContext* aStyleContext, const nsCSSValue& aValue, Position& aComputedValue, RuleNodeCacheConditions& aConditions) { NS_ASSERTION(aValue.GetUnit() == eCSSUnit_Array, "unexpected unit for CSS <position> value"); RefPtr<nsCSSValue::Array> positionArray = aValue.GetArrayValue(); NS_ASSERTION(positionArray->Count() == 4, "unexpected number of values in CSS <position> value"); const nsCSSValue &xEdge = positionArray->Item(0); const nsCSSValue &xOffset = positionArray->Item(1); const nsCSSValue &yEdge = positionArray->Item(2); const nsCSSValue &yOffset = positionArray->Item(3); NS_ASSERTION((eCSSUnit_Enumerated == xEdge.GetUnit() || eCSSUnit_Null == xEdge.GetUnit()) && (eCSSUnit_Enumerated == yEdge.GetUnit() || eCSSUnit_Null == yEdge.GetUnit()) && eCSSUnit_Enumerated != xOffset.GetUnit() && eCSSUnit_Enumerated != yOffset.GetUnit(), "Invalid background position"); ComputePositionCoord(aStyleContext, xEdge, xOffset, &aComputedValue.mXPosition, aConditions); ComputePositionCoord(aStyleContext, yEdge, yOffset, &aComputedValue.mYPosition, aConditions); } /* Helper function to convert the -x or -y part of a CSS <position> specified * value into its computed-style form. */ static void ComputePositionCoordValue(nsStyleContext* aStyleContext, const nsCSSValue& aValue, Position::Coord& aComputedValue, RuleNodeCacheConditions& aConditions) { NS_ASSERTION(aValue.GetUnit() == eCSSUnit_Array, "unexpected unit for position coord value"); RefPtr<nsCSSValue::Array> positionArray = aValue.GetArrayValue(); NS_ASSERTION(positionArray->Count() == 2, "unexpected number of values, expecting one edge and one offset"); const nsCSSValue &edge = positionArray->Item(0); const nsCSSValue &offset = positionArray->Item(1); NS_ASSERTION((eCSSUnit_Enumerated == edge.GetUnit() || eCSSUnit_Null == edge.GetUnit()) && eCSSUnit_Enumerated != offset.GetUnit(), "Invalid background position"); ComputePositionCoord(aStyleContext, edge, offset, &aComputedValue, aConditions); } struct BackgroundSizeAxis { nsCSSValue nsCSSValuePairList::* specified; nsStyleImageLayers::Size::Dimension nsStyleImageLayers::Size::* result; uint8_t nsStyleImageLayers::Size::* type; }; static const BackgroundSizeAxis gBGSizeAxes[] = { { &nsCSSValuePairList::mXValue, &nsStyleImageLayers::Size::mWidth, &nsStyleImageLayers::Size::mWidthType }, { &nsCSSValuePairList::mYValue, &nsStyleImageLayers::Size::mHeight, &nsStyleImageLayers::Size::mHeightType } }; template <> struct BackgroundItemComputer<nsCSSValuePairList, nsStyleImageLayers::Size> { static void ComputeValue(nsStyleContext* aStyleContext, const nsCSSValuePairList* aSpecifiedValue, nsStyleImageLayers::Size& aComputedValue, RuleNodeCacheConditions& aConditions) { nsStyleImageLayers::Size &size = aComputedValue; for (const BackgroundSizeAxis *axis = gBGSizeAxes, *axis_end = ArrayEnd(gBGSizeAxes); axis < axis_end; ++axis) { const nsCSSValue &specified = aSpecifiedValue->*(axis->specified); if (eCSSUnit_Auto == specified.GetUnit()) { size.*(axis->type) = nsStyleImageLayers::Size::eAuto; } else if (eCSSUnit_Enumerated == specified.GetUnit()) { static_assert(nsStyleImageLayers::Size::eContain == NS_STYLE_IMAGELAYER_SIZE_CONTAIN && nsStyleImageLayers::Size::eCover == NS_STYLE_IMAGELAYER_SIZE_COVER, "background size constants out of sync"); MOZ_ASSERT(specified.GetIntValue() == NS_STYLE_IMAGELAYER_SIZE_CONTAIN || specified.GetIntValue() == NS_STYLE_IMAGELAYER_SIZE_COVER, "invalid enumerated value for size coordinate"); size.*(axis->type) = specified.GetIntValue(); } else if (eCSSUnit_Null == specified.GetUnit()) { MOZ_ASSERT(axis == gBGSizeAxes + 1, "null allowed only as height value, and only " "for contain/cover/initial/inherit"); #ifdef DEBUG { const nsCSSValue &widthValue = aSpecifiedValue->mXValue; MOZ_ASSERT(widthValue.GetUnit() != eCSSUnit_Inherit && widthValue.GetUnit() != eCSSUnit_Initial && widthValue.GetUnit() != eCSSUnit_Unset, "initial/inherit/unset should already have been handled"); MOZ_ASSERT(widthValue.GetUnit() == eCSSUnit_Enumerated && (widthValue.GetIntValue() == NS_STYLE_IMAGELAYER_SIZE_CONTAIN || widthValue.GetIntValue() == NS_STYLE_IMAGELAYER_SIZE_COVER), "null height value not corresponding to allowable " "non-null width value"); } #endif size.*(axis->type) = size.mWidthType; } else if (eCSSUnit_Percent == specified.GetUnit()) { (size.*(axis->result)).mLength = 0; (size.*(axis->result)).mPercent = specified.GetPercentValue(); (size.*(axis->result)).mHasPercent = true; size.*(axis->type) = nsStyleImageLayers::Size::eLengthPercentage; } else if (specified.IsLengthUnit()) { (size.*(axis->result)).mLength = CalcLength(specified, aStyleContext, aStyleContext->PresContext(), aConditions); (size.*(axis->result)).mPercent = 0.0f; (size.*(axis->result)).mHasPercent = false; size.*(axis->type) = nsStyleImageLayers::Size::eLengthPercentage; } else { MOZ_ASSERT(specified.IsCalcUnit(), "unexpected unit"); LengthPercentPairCalcOps ops(aStyleContext, aStyleContext->PresContext(), aConditions); nsRuleNode::ComputedCalc vals = ComputeCalc(specified, ops); (size.*(axis->result)).mLength = vals.mLength; (size.*(axis->result)).mPercent = vals.mPercent; (size.*(axis->result)).mHasPercent = ops.mHasPercent; size.*(axis->type) = nsStyleImageLayers::Size::eLengthPercentage; } } MOZ_ASSERT(size.mWidthType < nsStyleImageLayers::Size::eDimensionType_COUNT, "bad width type"); MOZ_ASSERT(size.mHeightType < nsStyleImageLayers::Size::eDimensionType_COUNT, "bad height type"); MOZ_ASSERT((size.mWidthType != nsStyleImageLayers::Size::eContain && size.mWidthType != nsStyleImageLayers::Size::eCover) || size.mWidthType == size.mHeightType, "contain/cover apply to both dimensions or to neither"); } }; template <class ComputedValueItem> static void SetImageLayerList(nsStyleContext* aStyleContext, const nsCSSValue& aValue, nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers, const nsStyleAutoArray<nsStyleImageLayers::Layer>& aParentLayers, ComputedValueItem nsStyleImageLayers::Layer::* aResultLocation, ComputedValueItem aInitialValue, uint32_t aParentItemCount, uint32_t& aItemCount, uint32_t& aMaxItemCount, bool& aRebuild, RuleNodeCacheConditions& aConditions) { switch (aValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: aRebuild = true; aConditions.SetUncacheable(); aLayers.EnsureLengthAtLeast(aParentItemCount); aItemCount = aParentItemCount; for (uint32_t i = 0; i < aParentItemCount; ++i) { aLayers[i].*aResultLocation = aParentLayers[i].*aResultLocation; } break; case eCSSUnit_Initial: case eCSSUnit_Unset: aRebuild = true; aItemCount = 1; aLayers[0].*aResultLocation = aInitialValue; break; case eCSSUnit_List: case eCSSUnit_ListDep: { aRebuild = true; aItemCount = 0; const nsCSSValueList* item = aValue.GetListValue(); do { NS_ASSERTION(item->mValue.GetUnit() != eCSSUnit_Null && item->mValue.GetUnit() != eCSSUnit_Inherit && item->mValue.GetUnit() != eCSSUnit_Initial && item->mValue.GetUnit() != eCSSUnit_Unset, "unexpected unit"); ++aItemCount; aLayers.EnsureLengthAtLeast(aItemCount); BackgroundItemComputer<nsCSSValueList, ComputedValueItem> ::ComputeValue(aStyleContext, item, aLayers[aItemCount-1].*aResultLocation, aConditions); item = item->mNext; } while (item); break; } default: MOZ_ASSERT(false, "unexpected unit"); } if (aItemCount > aMaxItemCount) aMaxItemCount = aItemCount; } // The same as SetImageLayerList, but for values stored in // layer.mPosition.*aResultLocation instead of layer.*aResultLocation. // This code is duplicated because it would be annoying to make // SetImageLayerList generic enough to handle both cases. static void SetImageLayerPositionCoordList( nsStyleContext* aStyleContext, const nsCSSValue& aValue, nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers, const nsStyleAutoArray<nsStyleImageLayers::Layer>& aParentLayers, Position::Coord Position::* aResultLocation, Position::Coord aInitialValue, uint32_t aParentItemCount, uint32_t& aItemCount, uint32_t& aMaxItemCount, bool& aRebuild, RuleNodeCacheConditions& aConditions) { switch (aValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: aRebuild = true; aConditions.SetUncacheable(); aLayers.EnsureLengthAtLeast(aParentItemCount); aItemCount = aParentItemCount; for (uint32_t i = 0; i < aParentItemCount; ++i) { aLayers[i].mPosition.*aResultLocation = aParentLayers[i].mPosition.*aResultLocation; } break; case eCSSUnit_Initial: case eCSSUnit_Unset: aRebuild = true; aItemCount = 1; aLayers[0].mPosition.*aResultLocation = aInitialValue; break; case eCSSUnit_List: case eCSSUnit_ListDep: { aRebuild = true; aItemCount = 0; const nsCSSValueList* item = aValue.GetListValue(); do { NS_ASSERTION(item->mValue.GetUnit() != eCSSUnit_Null && item->mValue.GetUnit() != eCSSUnit_Inherit && item->mValue.GetUnit() != eCSSUnit_Initial && item->mValue.GetUnit() != eCSSUnit_Unset, "unexpected unit"); ++aItemCount; aLayers.EnsureLengthAtLeast(aItemCount); ComputePositionCoordValue(aStyleContext, item->mValue, aLayers[aItemCount-1].mPosition.*aResultLocation, aConditions); item = item->mNext; } while (item); break; } default: MOZ_ASSERT(false, "unexpected unit"); } if (aItemCount > aMaxItemCount) aMaxItemCount = aItemCount; } template <class ComputedValueItem> static void SetImageLayerPairList(nsStyleContext* aStyleContext, const nsCSSValue& aValue, nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers, const nsStyleAutoArray<nsStyleImageLayers::Layer>& aParentLayers, ComputedValueItem nsStyleImageLayers::Layer::* aResultLocation, ComputedValueItem aInitialValue, uint32_t aParentItemCount, uint32_t& aItemCount, uint32_t& aMaxItemCount, bool& aRebuild, RuleNodeCacheConditions& aConditions) { switch (aValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: aRebuild = true; aConditions.SetUncacheable(); aLayers.EnsureLengthAtLeast(aParentItemCount); aItemCount = aParentItemCount; for (uint32_t i = 0; i < aParentItemCount; ++i) { aLayers[i].*aResultLocation = aParentLayers[i].*aResultLocation; } break; case eCSSUnit_Initial: case eCSSUnit_Unset: aRebuild = true; aItemCount = 1; aLayers[0].*aResultLocation = aInitialValue; break; case eCSSUnit_PairList: case eCSSUnit_PairListDep: { aRebuild = true; aItemCount = 0; const nsCSSValuePairList* item = aValue.GetPairListValue(); do { NS_ASSERTION(item->mXValue.GetUnit() != eCSSUnit_Inherit && item->mXValue.GetUnit() != eCSSUnit_Initial && item->mXValue.GetUnit() != eCSSUnit_Unset && item->mYValue.GetUnit() != eCSSUnit_Inherit && item->mYValue.GetUnit() != eCSSUnit_Initial && item->mYValue.GetUnit() != eCSSUnit_Unset, "unexpected unit"); ++aItemCount; aLayers.EnsureLengthAtLeast(aItemCount); BackgroundItemComputer<nsCSSValuePairList, ComputedValueItem> ::ComputeValue(aStyleContext, item, aLayers[aItemCount-1].*aResultLocation, aConditions); item = item->mNext; } while (item); break; } default: MOZ_ASSERT(false, "unexpected unit"); } if (aItemCount > aMaxItemCount) aMaxItemCount = aItemCount; } template <class ComputedValueItem> static void FillImageLayerList( nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers, ComputedValueItem nsStyleImageLayers::Layer::* aResultLocation, uint32_t aItemCount, uint32_t aFillCount) { NS_PRECONDITION(aFillCount <= aLayers.Length(), "unexpected array length"); for (uint32_t sourceLayer = 0, destLayer = aItemCount; destLayer < aFillCount; ++sourceLayer, ++destLayer) { aLayers[destLayer].*aResultLocation = aLayers[sourceLayer].*aResultLocation; } } // The same as FillImageLayerList, but for values stored in // layer.mPosition.*aResultLocation instead of layer.*aResultLocation. static void FillImageLayerPositionCoordList( nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers, Position::Coord Position::* aResultLocation, uint32_t aItemCount, uint32_t aFillCount) { NS_PRECONDITION(aFillCount <= aLayers.Length(), "unexpected array length"); for (uint32_t sourceLayer = 0, destLayer = aItemCount; destLayer < aFillCount; ++sourceLayer, ++destLayer) { aLayers[destLayer].mPosition.*aResultLocation = aLayers[sourceLayer].mPosition.*aResultLocation; } } /* static */ void nsRuleNode::FillAllBackgroundLists(nsStyleImageLayers& aImage, uint32_t aMaxItemCount) { // Delete any extra items. We need to keep layers in which any // property was specified. aImage.mLayers.TruncateLengthNonZero(aMaxItemCount); uint32_t fillCount = aImage.mImageCount; FillImageLayerList(aImage.mLayers, &nsStyleImageLayers::Layer::mImage, aImage.mImageCount, fillCount); FillImageLayerList(aImage.mLayers, &nsStyleImageLayers::Layer::mRepeat, aImage.mRepeatCount, fillCount); FillImageLayerList(aImage.mLayers, &nsStyleImageLayers::Layer::mAttachment, aImage.mAttachmentCount, fillCount); FillImageLayerList(aImage.mLayers, &nsStyleImageLayers::Layer::mClip, aImage.mClipCount, fillCount); FillImageLayerList(aImage.mLayers, &nsStyleImageLayers::Layer::mBlendMode, aImage.mBlendModeCount, fillCount); FillImageLayerList(aImage.mLayers, &nsStyleImageLayers::Layer::mOrigin, aImage.mOriginCount, fillCount); FillImageLayerPositionCoordList(aImage.mLayers, &Position::mXPosition, aImage.mPositionXCount, fillCount); FillImageLayerPositionCoordList(aImage.mLayers, &Position::mYPosition, aImage.mPositionYCount, fillCount); FillImageLayerList(aImage.mLayers, &nsStyleImageLayers::Layer::mSize, aImage.mSizeCount, fillCount); } const void* nsRuleNode::ComputeBackgroundData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Background, bg, parentBG) // background-color: color, string, inherit const nsCSSValue* backColorValue = aRuleData->ValueForBackgroundColor(); if (eCSSUnit_Initial == backColorValue->GetUnit() || eCSSUnit_Unset == backColorValue->GetUnit()) { bg->mBackgroundColor = NS_RGBA(0, 0, 0, 0); } else if (!SetColor(*backColorValue, parentBG->mBackgroundColor, mPresContext, aContext, bg->mBackgroundColor, conditions)) { NS_ASSERTION(eCSSUnit_Null == backColorValue->GetUnit(), "unexpected color unit"); } uint32_t maxItemCount = 1; bool rebuild = false; // background-image: url (stored as image), none, inherit [list] nsStyleImage initialImage; SetImageLayerList(aContext, *aRuleData->ValueForBackgroundImage(), bg->mImage.mLayers, parentBG->mImage.mLayers, &nsStyleImageLayers::Layer::mImage, initialImage, parentBG->mImage.mImageCount, bg->mImage.mImageCount, maxItemCount, rebuild, conditions); // background-repeat: enum, inherit, initial [pair list] nsStyleImageLayers::Repeat initialRepeat; initialRepeat.SetInitialValues(); SetImageLayerPairList(aContext, *aRuleData->ValueForBackgroundRepeat(), bg->mImage.mLayers, parentBG->mImage.mLayers, &nsStyleImageLayers::Layer::mRepeat, initialRepeat, parentBG->mImage.mRepeatCount, bg->mImage.mRepeatCount, maxItemCount, rebuild, conditions); // background-attachment: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForBackgroundAttachment(), bg->mImage.mLayers, parentBG->mImage.mLayers, &nsStyleImageLayers::Layer::mAttachment, uint8_t(NS_STYLE_IMAGELAYER_ATTACHMENT_SCROLL), parentBG->mImage.mAttachmentCount, bg->mImage.mAttachmentCount, maxItemCount, rebuild, conditions); // background-clip: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForBackgroundClip(), bg->mImage.mLayers, parentBG->mImage.mLayers, &nsStyleImageLayers::Layer::mClip, StyleGeometryBox::Border, parentBG->mImage.mClipCount, bg->mImage.mClipCount, maxItemCount, rebuild, conditions); // background-blend-mode: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForBackgroundBlendMode(), bg->mImage.mLayers, parentBG->mImage.mLayers, &nsStyleImageLayers::Layer::mBlendMode, uint8_t(NS_STYLE_BLEND_NORMAL), parentBG->mImage.mBlendModeCount, bg->mImage.mBlendModeCount, maxItemCount, rebuild, conditions); // background-origin: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForBackgroundOrigin(), bg->mImage.mLayers, parentBG->mImage.mLayers, &nsStyleImageLayers::Layer::mOrigin, StyleGeometryBox::Padding, parentBG->mImage.mOriginCount, bg->mImage.mOriginCount, maxItemCount, rebuild, conditions); // background-position-x/y: enum, length, percent (flags), inherit [list] Position::Coord initialPositionCoord; initialPositionCoord.mPercent = 0.0f; initialPositionCoord.mLength = 0; initialPositionCoord.mHasPercent = true; SetImageLayerPositionCoordList( aContext, *aRuleData->ValueForBackgroundPositionX(), bg->mImage.mLayers, parentBG->mImage.mLayers, &Position::mXPosition, initialPositionCoord, parentBG->mImage.mPositionXCount, bg->mImage.mPositionXCount, maxItemCount, rebuild, conditions); SetImageLayerPositionCoordList( aContext, *aRuleData->ValueForBackgroundPositionY(), bg->mImage.mLayers, parentBG->mImage.mLayers, &Position::mYPosition, initialPositionCoord, parentBG->mImage.mPositionYCount, bg->mImage.mPositionYCount, maxItemCount, rebuild, conditions); // background-size: enum, length, auto, inherit, initial [pair list] nsStyleImageLayers::Size initialSize; initialSize.SetInitialValues(); SetImageLayerPairList(aContext, *aRuleData->ValueForBackgroundSize(), bg->mImage.mLayers, parentBG->mImage.mLayers, &nsStyleImageLayers::Layer::mSize, initialSize, parentBG->mImage.mSizeCount, bg->mImage.mSizeCount, maxItemCount, rebuild, conditions); if (rebuild) { FillAllBackgroundLists(bg->mImage, maxItemCount); } COMPUTE_END_RESET(Background, bg) } const void* nsRuleNode::ComputeMarginData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Margin, margin, parentMargin) // margin: length, percent, calc, inherit const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(eCSSProperty_margin); nsStyleCoord coord; NS_FOR_CSS_SIDES(side) { nsStyleCoord parentCoord = parentMargin->mMargin.Get(side); if (SetCoord(*aRuleData->ValueFor(subprops[side]), coord, parentCoord, SETCOORD_LPAH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { margin->mMargin.Set(side, coord); } } COMPUTE_END_RESET(Margin, margin) } static void SetBorderImageRect(const nsCSSValue& aValue, /** outparam */ nsCSSRect& aRect) { switch (aValue.GetUnit()) { case eCSSUnit_Null: aRect.Reset(); break; case eCSSUnit_Rect: aRect = aValue.GetRectValue(); break; case eCSSUnit_Inherit: case eCSSUnit_Initial: case eCSSUnit_Unset: aRect.SetAllSidesTo(aValue); break; default: NS_ASSERTION(false, "Unexpected border image value for rect."); } } static void SetBorderImagePair(const nsCSSValue& aValue, /** outparam */ nsCSSValuePair& aPair) { switch (aValue.GetUnit()) { case eCSSUnit_Null: aPair.Reset(); break; case eCSSUnit_Pair: aPair = aValue.GetPairValue(); break; case eCSSUnit_Inherit: case eCSSUnit_Initial: case eCSSUnit_Unset: aPair.SetBothValuesTo(aValue); break; default: NS_ASSERTION(false, "Unexpected border image value for pair."); } } static void SetBorderImageSlice(const nsCSSValue& aValue, /** outparam */ nsCSSValue& aSlice, /** outparam */ nsCSSValue& aFill) { const nsCSSValueList* valueList; switch (aValue.GetUnit()) { case eCSSUnit_Null: aSlice.Reset(); aFill.Reset(); break; case eCSSUnit_List: // Get slice dimensions. valueList = aValue.GetListValue(); aSlice = valueList->mValue; // Get "fill" keyword. valueList = valueList->mNext; if (valueList) { aFill = valueList->mValue; } else { aFill.SetInitialValue(); } break; case eCSSUnit_Inherit: case eCSSUnit_Initial: case eCSSUnit_Unset: aSlice = aValue; aFill = aValue; break; default: NS_ASSERTION(false, "Unexpected border image value for pair."); } } const void* nsRuleNode::ComputeBorderData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Border, border, parentBorder) // box-decoration-break: enum, inherit, initial SetValue(*aRuleData->ValueForBoxDecorationBreak(), border->mBoxDecorationBreak, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentBorder->mBoxDecorationBreak, StyleBoxDecorationBreak::Slice); // border-width, border-*-width: length, enum, inherit nsStyleCoord coord; { const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_width); NS_FOR_CSS_SIDES(side) { const nsCSSValue& value = *aRuleData->ValueFor(subprops[side]); NS_ASSERTION(eCSSUnit_Percent != value.GetUnit(), "Percentage borders not implemented yet " "If implementing, make sure to fix all consumers of " "nsStyleBorder, the IsPercentageAwareChild method, " "the nsAbsoluteContainingBlock::FrameDependsOnContainer " "method, the " "nsLineLayout::IsPercentageAwareReplacedElement method " "and probably some other places"); if (eCSSUnit_Enumerated == value.GetUnit()) { NS_ASSERTION(value.GetIntValue() == NS_STYLE_BORDER_WIDTH_THIN || value.GetIntValue() == NS_STYLE_BORDER_WIDTH_MEDIUM || value.GetIntValue() == NS_STYLE_BORDER_WIDTH_THICK, "Unexpected enum value"); border->SetBorderWidth(side, (mPresContext->GetBorderWidthTable())[value.GetIntValue()]); } // OK to pass bad aParentCoord since we're not passing SETCOORD_INHERIT else if (SetCoord(value, coord, nsStyleCoord(), SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY, aContext, mPresContext, conditions)) { NS_ASSERTION(coord.GetUnit() == eStyleUnit_Coord, "unexpected unit"); // clamp negative calc() to 0. border->SetBorderWidth(side, std::max(coord.GetCoordValue(), 0)); } else if (eCSSUnit_Inherit == value.GetUnit()) { conditions.SetUncacheable(); border->SetBorderWidth(side, parentBorder->GetComputedBorder().Side(side)); } else if (eCSSUnit_Initial == value.GetUnit() || eCSSUnit_Unset == value.GetUnit()) { border->SetBorderWidth(side, (mPresContext->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM]); } else { NS_ASSERTION(eCSSUnit_Null == value.GetUnit(), "missing case handling border width"); } } } // border-style, border-*-style: enum, inherit { const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_style); NS_FOR_CSS_SIDES(side) { const nsCSSValue& value = *aRuleData->ValueFor(subprops[side]); nsCSSUnit unit = value.GetUnit(); MOZ_ASSERT(eCSSUnit_None != unit, "'none' should be handled as enumerated value"); if (eCSSUnit_Enumerated == unit) { border->SetBorderStyle(side, value.GetIntValue()); } else if (eCSSUnit_Initial == unit || eCSSUnit_Unset == unit) { border->SetBorderStyle(side, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == unit) { conditions.SetUncacheable(); border->SetBorderStyle(side, parentBorder->GetBorderStyle(side)); } } } // -moz-border-*-colors: color, string, enum, none, inherit/initial nscolor borderColor; nscolor unused = NS_RGB(0,0,0); static const nsCSSPropertyID borderColorsProps[] = { eCSSProperty_border_top_colors, eCSSProperty_border_right_colors, eCSSProperty_border_bottom_colors, eCSSProperty_border_left_colors }; NS_FOR_CSS_SIDES(side) { const nsCSSValue& value = *aRuleData->ValueFor(borderColorsProps[side]); switch (value.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: border->ClearBorderColors(side); break; case eCSSUnit_Inherit: { conditions.SetUncacheable(); border->ClearBorderColors(side); if (parentContext) { nsBorderColors *parentColors; parentBorder->GetCompositeColors(side, &parentColors); if (parentColors) { border->EnsureBorderColors(); border->mBorderColors[side] = parentColors->Clone(); } } break; } case eCSSUnit_List: case eCSSUnit_ListDep: { // Some composite border color information has been specified for this // border side. border->EnsureBorderColors(); border->ClearBorderColors(side); const nsCSSValueList* list = value.GetListValue(); while (list) { if (SetColor(list->mValue, unused, mPresContext, aContext, borderColor, conditions)) border->AppendBorderColor(side, borderColor); else { NS_NOTREACHED("unexpected item in -moz-border-*-colors list"); } list = list->mNext; } break; } default: MOZ_ASSERT(false, "unrecognized border color unit"); } } // border-color, border-*-color: color, string, enum, inherit { const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_color); NS_FOR_CSS_SIDES(side) { SetComplexColor<eUnsetInitial>(*aRuleData->ValueFor(subprops[side]), parentBorder->mBorderColor[side], StyleComplexColor::CurrentColor(), mPresContext, border->mBorderColor[side], conditions); } } // border-radius: length, percent, inherit { const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_radius); NS_FOR_CSS_FULL_CORNERS(corner) { int cx = NS_FULL_TO_HALF_CORNER(corner, false); int cy = NS_FULL_TO_HALF_CORNER(corner, true); const nsCSSValue& radius = *aRuleData->ValueFor(subprops[corner]); nsStyleCoord parentX = parentBorder->mBorderRadius.Get(cx); nsStyleCoord parentY = parentBorder->mBorderRadius.Get(cy); nsStyleCoord coordX, coordY; if (SetPairCoords(radius, coordX, coordY, parentX, parentY, SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { border->mBorderRadius.Set(cx, coordX); border->mBorderRadius.Set(cy, coordY); } } } // float-edge: enum, inherit, initial SetValue(*aRuleData->ValueForFloatEdge(), border->mFloatEdge, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentBorder->mFloatEdge, StyleFloatEdge::ContentBox); // border-image-source const nsCSSValue* borderImageSource = aRuleData->ValueForBorderImageSource(); if (borderImageSource->GetUnit() == eCSSUnit_Inherit) { conditions.SetUncacheable(); border->mBorderImageSource = parentBorder->mBorderImageSource; } else { SetStyleImage(aContext, *borderImageSource, border->mBorderImageSource, conditions); } nsCSSValue borderImageSliceValue; nsCSSValue borderImageSliceFill; SetBorderImageSlice(*aRuleData->ValueForBorderImageSlice(), borderImageSliceValue, borderImageSliceFill); // border-image-slice: fill SetValue(borderImageSliceFill, border->mBorderImageFill, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentBorder->mBorderImageFill, NS_STYLE_BORDER_IMAGE_SLICE_NOFILL); nsCSSRect borderImageSlice; SetBorderImageRect(borderImageSliceValue, borderImageSlice); nsCSSRect borderImageWidth; SetBorderImageRect(*aRuleData->ValueForBorderImageWidth(), borderImageWidth); nsCSSRect borderImageOutset; SetBorderImageRect(*aRuleData->ValueForBorderImageOutset(), borderImageOutset); NS_FOR_CSS_SIDES (side) { // border-image-slice if (SetCoord(borderImageSlice.*(nsCSSRect::sides[side]), coord, parentBorder->mBorderImageSlice.Get(side), SETCOORD_FACTOR | SETCOORD_PERCENT | SETCOORD_INHERIT | SETCOORD_INITIAL_HUNDRED_PCT | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { border->mBorderImageSlice.Set(side, coord); } // border-image-width // 'auto' here means "same as slice" if (SetCoord(borderImageWidth.*(nsCSSRect::sides[side]), coord, parentBorder->mBorderImageWidth.Get(side), SETCOORD_LPAH | SETCOORD_FACTOR | SETCOORD_INITIAL_FACTOR_ONE | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { border->mBorderImageWidth.Set(side, coord); } // border-image-outset if (SetCoord(borderImageOutset.*(nsCSSRect::sides[side]), coord, parentBorder->mBorderImageOutset.Get(side), SETCOORD_LENGTH | SETCOORD_FACTOR | SETCOORD_INHERIT | SETCOORD_INITIAL_FACTOR_ZERO | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { border->mBorderImageOutset.Set(side, coord); } } // border-image-repeat nsCSSValuePair borderImageRepeat; SetBorderImagePair(*aRuleData->ValueForBorderImageRepeat(), borderImageRepeat); SetValue(borderImageRepeat.mXValue, border->mBorderImageRepeatH, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentBorder->mBorderImageRepeatH, NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH); SetValue(borderImageRepeat.mYValue, border->mBorderImageRepeatV, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentBorder->mBorderImageRepeatV, NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH); COMPUTE_END_RESET(Border, border) } const void* nsRuleNode::ComputePaddingData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Padding, padding, parentPadding) // padding: length, percent, calc, inherit const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(eCSSProperty_padding); nsStyleCoord coord; NS_FOR_CSS_SIDES(side) { nsStyleCoord parentCoord = parentPadding->mPadding.Get(side); if (SetCoord(*aRuleData->ValueFor(subprops[side]), coord, parentCoord, SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { padding->mPadding.Set(side, coord); } } COMPUTE_END_RESET(Padding, padding) } const void* nsRuleNode::ComputeOutlineData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Outline, outline, parentOutline) // outline-width: length, enum, inherit const nsCSSValue* outlineWidthValue = aRuleData->ValueForOutlineWidth(); if (eCSSUnit_Initial == outlineWidthValue->GetUnit() || eCSSUnit_Unset == outlineWidthValue->GetUnit()) { outline->mOutlineWidth = nsStyleCoord(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); } else { SetCoord(*outlineWidthValue, outline->mOutlineWidth, parentOutline->mOutlineWidth, SETCOORD_LEH | SETCOORD_CALC_LENGTH_ONLY, aContext, mPresContext, conditions); } // outline-offset: length, inherit nsStyleCoord tempCoord; const nsCSSValue* outlineOffsetValue = aRuleData->ValueForOutlineOffset(); if (SetCoord(*outlineOffsetValue, tempCoord, nsStyleCoord(parentOutline->mOutlineOffset, nsStyleCoord::CoordConstructor), SETCOORD_LH | SETCOORD_INITIAL_ZERO | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { outline->mOutlineOffset = tempCoord.GetCoordValue(); } else { NS_ASSERTION(outlineOffsetValue->GetUnit() == eCSSUnit_Null, "unexpected unit"); } // outline-color: color, string, enum, inherit SetComplexColor<eUnsetInitial>(*aRuleData->ValueForOutlineColor(), parentOutline->mOutlineColor, StyleComplexColor::CurrentColor(), mPresContext, outline->mOutlineColor, conditions); // -moz-outline-radius: length, percent, inherit { const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(eCSSProperty__moz_outline_radius); NS_FOR_CSS_FULL_CORNERS(corner) { int cx = NS_FULL_TO_HALF_CORNER(corner, false); int cy = NS_FULL_TO_HALF_CORNER(corner, true); const nsCSSValue& radius = *aRuleData->ValueFor(subprops[corner]); nsStyleCoord parentX = parentOutline->mOutlineRadius.Get(cx); nsStyleCoord parentY = parentOutline->mOutlineRadius.Get(cy); nsStyleCoord coordX, coordY; if (SetPairCoords(radius, coordX, coordY, parentX, parentY, SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { outline->mOutlineRadius.Set(cx, coordX); outline->mOutlineRadius.Set(cy, coordY); } } } // outline-style: enum, inherit, initial // cannot use SetValue because of SetOutlineStyle const nsCSSValue* outlineStyleValue = aRuleData->ValueForOutlineStyle(); nsCSSUnit unit = outlineStyleValue->GetUnit(); MOZ_ASSERT(eCSSUnit_None != unit && eCSSUnit_Auto != unit, "'none' and 'auto' should be handled as enumerated values"); if (eCSSUnit_Enumerated == unit) { outline->mOutlineStyle = outlineStyleValue->GetIntValue(); } else if (eCSSUnit_Initial == unit || eCSSUnit_Unset == unit) { outline->mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE; } else if (eCSSUnit_Inherit == unit) { conditions.SetUncacheable(); outline->mOutlineStyle = parentOutline->mOutlineStyle; } outline->RecalcData(); COMPUTE_END_RESET(Outline, outline) } const void* nsRuleNode::ComputeListData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(List, list, parentList) // quotes: inherit, initial, none, [string string]+ const nsCSSValue* quotesValue = aRuleData->ValueForQuotes(); switch (quotesValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: case eCSSUnit_Unset: conditions.SetUncacheable(); list->SetQuotesInherit(parentList); break; case eCSSUnit_Initial: list->SetQuotesInitial(); break; case eCSSUnit_None: list->SetQuotesNone(); break; case eCSSUnit_PairList: case eCSSUnit_PairListDep: { const nsCSSValuePairList* ourQuotes = quotesValue->GetPairListValue(); nsStyleQuoteValues::QuotePairArray quotePairs; quotePairs.SetLength(ListLength(ourQuotes)); size_t index = 0; nsAutoString buffer; while (ourQuotes) { MOZ_ASSERT(ourQuotes->mXValue.GetUnit() == eCSSUnit_String && ourQuotes->mYValue.GetUnit() == eCSSUnit_String, "improper list contents for quotes"); quotePairs[index].first = ourQuotes->mXValue.GetStringValue(buffer); quotePairs[index].second = ourQuotes->mYValue.GetStringValue(buffer); ++index; ourQuotes = ourQuotes->mNext; } list->SetQuotes(Move(quotePairs)); break; } default: MOZ_ASSERT(false, "unexpected value unit"); } // list-style-type: string, none, inherit, initial const nsCSSValue* typeValue = aRuleData->ValueForListStyleType(); switch (typeValue->GetUnit()) { case eCSSUnit_Unset: case eCSSUnit_Inherit: { conditions.SetUncacheable(); list->SetCounterStyle(parentList->GetCounterStyle()); break; } case eCSSUnit_Initial: list->SetListStyleType(NS_LITERAL_STRING("disc"), mPresContext); break; case eCSSUnit_Ident: { nsString typeIdent; typeValue->GetStringValue(typeIdent); list->SetListStyleType(typeIdent, mPresContext); break; } case eCSSUnit_String: { nsString str; typeValue->GetStringValue(str); list->SetCounterStyle(new AnonymousCounterStyle(str)); break; } case eCSSUnit_Enumerated: { // For compatibility with html attribute map. // This branch should never be called for value from CSS. int32_t intValue = typeValue->GetIntValue(); nsAutoString name; switch (intValue) { case NS_STYLE_LIST_STYLE_LOWER_ROMAN: name.AssignLiteral(u"lower-roman"); break; case NS_STYLE_LIST_STYLE_UPPER_ROMAN: name.AssignLiteral(u"upper-roman"); break; case NS_STYLE_LIST_STYLE_LOWER_ALPHA: name.AssignLiteral(u"lower-alpha"); break; case NS_STYLE_LIST_STYLE_UPPER_ALPHA: name.AssignLiteral(u"upper-alpha"); break; default: CopyASCIItoUTF16(nsCSSProps::ValueToKeyword( intValue, nsCSSProps::kListStyleKTable), name); break; } list->SetListStyleType(name, mPresContext); break; } case eCSSUnit_Symbols: list->SetCounterStyle(new AnonymousCounterStyle(typeValue->GetArrayValue())); break; case eCSSUnit_Null: break; default: NS_NOTREACHED("Unexpected value unit"); } // list-style-image: url, none, inherit const nsCSSValue* imageValue = aRuleData->ValueForListStyleImage(); if (eCSSUnit_Image == imageValue->GetUnit()) { SetStyleImageRequest([&](nsStyleImageRequest* req) { list->mListStyleImage = req; }, mPresContext, *imageValue, nsStyleImageRequest::Mode(0)); } else if (eCSSUnit_None == imageValue->GetUnit() || eCSSUnit_Initial == imageValue->GetUnit()) { list->mListStyleImage = nullptr; } else if (eCSSUnit_Inherit == imageValue->GetUnit() || eCSSUnit_Unset == imageValue->GetUnit()) { conditions.SetUncacheable(); list->mListStyleImage = parentList->mListStyleImage; } // list-style-position: enum, inherit, initial SetValue(*aRuleData->ValueForListStylePosition(), list->mListStylePosition, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentList->mListStylePosition, NS_STYLE_LIST_STYLE_POSITION_OUTSIDE); // image region property: length, auto, inherit const nsCSSValue* imageRegionValue = aRuleData->ValueForImageRegion(); switch (imageRegionValue->GetUnit()) { case eCSSUnit_Inherit: case eCSSUnit_Unset: conditions.SetUncacheable(); list->mImageRegion = parentList->mImageRegion; break; case eCSSUnit_Initial: case eCSSUnit_Auto: list->mImageRegion.SetRect(0,0,0,0); break; case eCSSUnit_Null: break; case eCSSUnit_Rect: { const nsCSSRect& rgnRect = imageRegionValue->GetRectValue(); if (rgnRect.mTop.GetUnit() == eCSSUnit_Auto) list->mImageRegion.y = 0; else if (rgnRect.mTop.IsLengthUnit()) list->mImageRegion.y = CalcLength(rgnRect.mTop, aContext, mPresContext, conditions); if (rgnRect.mBottom.GetUnit() == eCSSUnit_Auto) list->mImageRegion.height = 0; else if (rgnRect.mBottom.IsLengthUnit()) list->mImageRegion.height = CalcLength(rgnRect.mBottom, aContext, mPresContext, conditions) - list->mImageRegion.y; if (rgnRect.mLeft.GetUnit() == eCSSUnit_Auto) list->mImageRegion.x = 0; else if (rgnRect.mLeft.IsLengthUnit()) list->mImageRegion.x = CalcLength(rgnRect.mLeft, aContext, mPresContext, conditions); if (rgnRect.mRight.GetUnit() == eCSSUnit_Auto) list->mImageRegion.width = 0; else if (rgnRect.mRight.IsLengthUnit()) list->mImageRegion.width = CalcLength(rgnRect.mRight, aContext, mPresContext, conditions) - list->mImageRegion.x; break; } default: MOZ_ASSERT(false, "unrecognized image-region unit"); } COMPUTE_END_INHERITED(List, list) } static void SetGridTrackBreadth(const nsCSSValue& aValue, nsStyleCoord& aResult, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { nsCSSUnit unit = aValue.GetUnit(); if (unit == eCSSUnit_FlexFraction) { aResult.SetFlexFractionValue(aValue.GetFloatValue()); } else if (unit == eCSSUnit_Auto) { aResult.SetAutoValue(); } else if (unit == eCSSUnit_None) { // For fit-content(). aResult.SetNoneValue(); } else { MOZ_ASSERT(unit != eCSSUnit_Inherit && unit != eCSSUnit_Unset, "Unexpected value that would use dummyParentCoord"); const nsStyleCoord dummyParentCoord; DebugOnly<bool> stored = SetCoord(aValue, aResult, dummyParentCoord, SETCOORD_LPE | SETCOORD_STORE_CALC, aStyleContext, aPresContext, aConditions); MOZ_ASSERT(stored, "invalid <track-size> value"); } } static void SetGridTrackSize(const nsCSSValue& aValue, nsStyleCoord& aResultMin, nsStyleCoord& aResultMax, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { if (aValue.GetUnit() == eCSSUnit_Function) { nsCSSValue::Array* func = aValue.GetArrayValue(); auto funcName = func->Item(0).GetKeywordValue(); if (funcName == eCSSKeyword_minmax) { SetGridTrackBreadth(func->Item(1), aResultMin, aStyleContext, aPresContext, aConditions); SetGridTrackBreadth(func->Item(2), aResultMax, aStyleContext, aPresContext, aConditions); } else if (funcName == eCSSKeyword_fit_content) { // We represent fit-content(L) as 'none' min-sizing and L max-sizing. SetGridTrackBreadth(nsCSSValue(eCSSUnit_None), aResultMin, aStyleContext, aPresContext, aConditions); SetGridTrackBreadth(func->Item(1), aResultMax, aStyleContext, aPresContext, aConditions); } else { NS_ERROR("Expected minmax() or fit-content(), got another function name"); } } else { // A single <track-breadth>, // specifies identical min and max sizing functions. SetGridTrackBreadth(aValue, aResultMin, aStyleContext, aPresContext, aConditions); aResultMax = aResultMin; } } static void SetGridAutoColumnsRows(const nsCSSValue& aValue, nsStyleCoord& aResultMin, nsStyleCoord& aResultMax, const nsStyleCoord& aParentValueMin, const nsStyleCoord& aParentValueMax, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { switch (aValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: aConditions.SetUncacheable(); aResultMin = aParentValueMin; aResultMax = aParentValueMax; break; case eCSSUnit_Initial: case eCSSUnit_Unset: // The initial value is 'auto', // which computes to 'minmax(auto, auto)'. // (Explicitly-specified 'auto' values are handled in SetGridTrackSize.) aResultMin.SetAutoValue(); aResultMax.SetAutoValue(); break; default: SetGridTrackSize(aValue, aResultMin, aResultMax, aStyleContext, aPresContext, aConditions); } } static void AppendGridLineNames(const nsCSSValue& aValue, nsTArray<nsString>& aNameList) { // Compute a <line-names> value // Null unit means empty list, nothing more to do. if (aValue.GetUnit() != eCSSUnit_Null) { const nsCSSValueList* item = aValue.GetListValue(); do { nsString* name = aNameList.AppendElement(); item->mValue.GetStringValue(*name); item = item->mNext; } while (item); } } static void SetGridTrackList(const nsCSSValue& aValue, nsStyleGridTemplate& aResult, const nsStyleGridTemplate& aParentValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { switch (aValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: aConditions.SetUncacheable(); aResult.mIsSubgrid = aParentValue.mIsSubgrid; aResult.mLineNameLists = aParentValue.mLineNameLists; aResult.mMinTrackSizingFunctions = aParentValue.mMinTrackSizingFunctions; aResult.mMaxTrackSizingFunctions = aParentValue.mMaxTrackSizingFunctions; aResult.mRepeatAutoLineNameListBefore = aParentValue.mRepeatAutoLineNameListBefore; aResult.mRepeatAutoLineNameListAfter = aParentValue.mRepeatAutoLineNameListAfter; aResult.mRepeatAutoIndex = aParentValue.mRepeatAutoIndex; aResult.mIsAutoFill = aParentValue.mIsAutoFill; break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: aResult.mIsSubgrid = false; aResult.mLineNameLists.Clear(); aResult.mMinTrackSizingFunctions.Clear(); aResult.mMaxTrackSizingFunctions.Clear(); aResult.mRepeatAutoLineNameListBefore.Clear(); aResult.mRepeatAutoLineNameListAfter.Clear(); aResult.mRepeatAutoIndex = -1; aResult.mIsAutoFill = false; break; default: aResult.mLineNameLists.Clear(); aResult.mMinTrackSizingFunctions.Clear(); aResult.mMaxTrackSizingFunctions.Clear(); aResult.mRepeatAutoLineNameListBefore.Clear(); aResult.mRepeatAutoLineNameListAfter.Clear(); aResult.mRepeatAutoIndex = -1; aResult.mIsAutoFill = false; const nsCSSValueList* item = aValue.GetListValue(); if (item->mValue.GetUnit() == eCSSUnit_Enumerated && item->mValue.GetIntValue() == NS_STYLE_GRID_TEMPLATE_SUBGRID) { // subgrid <line-name-list>? aResult.mIsSubgrid = true; item = item->mNext; for (int32_t i = 0; item && i < nsStyleGridLine::kMaxLine; ++i) { if (item->mValue.GetUnit() == eCSSUnit_Pair) { // This is a 'auto-fill' <name-repeat> expression. const nsCSSValuePair& pair = item->mValue.GetPairValue(); MOZ_ASSERT(aResult.mRepeatAutoIndex == -1, "can only have one <name-repeat> with auto-fill"); aResult.mRepeatAutoIndex = i; aResult.mIsAutoFill = true; MOZ_ASSERT(pair.mXValue.GetIntValue() == NS_STYLE_GRID_REPEAT_AUTO_FILL, "unexpected repeat() enum value for subgrid"); const nsCSSValueList* list = pair.mYValue.GetListValue(); AppendGridLineNames(list->mValue, aResult.mRepeatAutoLineNameListBefore); } else { AppendGridLineNames(item->mValue, *aResult.mLineNameLists.AppendElement()); } item = item->mNext; } } else { // <track-list> // The list is expected to have odd number of items, at least 3 // starting with a <line-names> (sub list of identifiers), // and alternating between that and <track-size>. aResult.mIsSubgrid = false; for (int32_t line = 1; ; ++line) { AppendGridLineNames(item->mValue, *aResult.mLineNameLists.AppendElement()); item = item->mNext; if (!item || line == nsStyleGridLine::kMaxLine) { break; } if (item->mValue.GetUnit() == eCSSUnit_Pair) { // This is a 'auto-fill' / 'auto-fit' <auto-repeat> expression. const nsCSSValuePair& pair = item->mValue.GetPairValue(); MOZ_ASSERT(aResult.mRepeatAutoIndex == -1, "can only have one <auto-repeat>"); aResult.mRepeatAutoIndex = line - 1; switch (pair.mXValue.GetIntValue()) { case NS_STYLE_GRID_REPEAT_AUTO_FILL: aResult.mIsAutoFill = true; break; case NS_STYLE_GRID_REPEAT_AUTO_FIT: aResult.mIsAutoFill = false; break; default: MOZ_ASSERT_UNREACHABLE("unexpected repeat() enum value"); } const nsCSSValueList* list = pair.mYValue.GetListValue(); AppendGridLineNames(list->mValue, aResult.mRepeatAutoLineNameListBefore); list = list->mNext; nsStyleCoord& min = *aResult.mMinTrackSizingFunctions.AppendElement(); nsStyleCoord& max = *aResult.mMaxTrackSizingFunctions.AppendElement(); SetGridTrackSize(list->mValue, min, max, aStyleContext, aPresContext, aConditions); list = list->mNext; AppendGridLineNames(list->mValue, aResult.mRepeatAutoLineNameListAfter); } else { nsStyleCoord& min = *aResult.mMinTrackSizingFunctions.AppendElement(); nsStyleCoord& max = *aResult.mMaxTrackSizingFunctions.AppendElement(); SetGridTrackSize(item->mValue, min, max, aStyleContext, aPresContext, aConditions); } item = item->mNext; MOZ_ASSERT(item, "Expected a eCSSUnit_List of odd length"); } MOZ_ASSERT(!aResult.mMinTrackSizingFunctions.IsEmpty() && aResult.mMinTrackSizingFunctions.Length() == aResult.mMaxTrackSizingFunctions.Length() && aResult.mMinTrackSizingFunctions.Length() + 1 == aResult.mLineNameLists.Length(), "Inconstistent array lengths for nsStyleGridTemplate"); } } } static void SetGridTemplateAreas(const nsCSSValue& aValue, RefPtr<css::GridTemplateAreasValue>* aResult, css::GridTemplateAreasValue* aParentValue, RuleNodeCacheConditions& aConditions) { switch (aValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: aConditions.SetUncacheable(); *aResult = aParentValue; break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: *aResult = nullptr; break; default: *aResult = aValue.GetGridTemplateAreas(); } } static void SetGridLine(const nsCSSValue& aValue, nsStyleGridLine& aResult, const nsStyleGridLine& aParentValue, RuleNodeCacheConditions& aConditions) { switch (aValue.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: aConditions.SetUncacheable(); aResult = aParentValue; break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_Auto: aResult.SetAuto(); break; default: aResult.SetAuto(); // Reset any existing value. const nsCSSValueList* item = aValue.GetListValue(); do { if (item->mValue.GetUnit() == eCSSUnit_Enumerated) { aResult.mHasSpan = true; } else if (item->mValue.GetUnit() == eCSSUnit_Integer) { aResult.mInteger = clamped(item->mValue.GetIntValue(), nsStyleGridLine::kMinLine, nsStyleGridLine::kMaxLine); } else if (item->mValue.GetUnit() == eCSSUnit_Ident) { item->mValue.GetStringValue(aResult.mLineName); } else { NS_ASSERTION(false, "Unexpected unit"); } item = item->mNext; } while (item); MOZ_ASSERT(!aResult.IsAuto(), "should have set something away from default value"); } } const void* nsRuleNode::ComputePositionData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Position, pos, parentPos) // box offsets: length, percent, calc, auto, inherit static const nsCSSPropertyID offsetProps[] = { eCSSProperty_top, eCSSProperty_right, eCSSProperty_bottom, eCSSProperty_left }; nsStyleCoord coord; NS_FOR_CSS_SIDES(side) { nsStyleCoord parentCoord = parentPos->mOffset.Get(side); if (SetCoord(*aRuleData->ValueFor(offsetProps[side]), coord, parentCoord, SETCOORD_LPAH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { pos->mOffset.Set(side, coord); } } // We allow the enumerated box size property values -moz-min-content, etc. to // be specified on both the {,min-,max-}width properties and the // {,min-,max-}height properties, regardless of the writing mode. This is // because the writing mode is not determined until here, at computed value // time. Since we do not support layout behavior of these keywords on the // block-axis properties, we turn them into unset if we find them in // that case. WritingMode wm(aContext); bool vertical = wm.IsVertical(); const nsCSSValue* width = aRuleData->ValueForWidth(); if (width->GetUnit() == eCSSUnit_Enumerated) { conditions.SetWritingModeDependency(wm.GetBits()); } SetCoord(width->GetUnit() == eCSSUnit_Enumerated && vertical ? nsCSSValue(eCSSUnit_Unset) : *width, pos->mWidth, parentPos->mWidth, SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); const nsCSSValue* minWidth = aRuleData->ValueForMinWidth(); if (minWidth->GetUnit() == eCSSUnit_Enumerated) { conditions.SetWritingModeDependency(wm.GetBits()); } SetCoord(minWidth->GetUnit() == eCSSUnit_Enumerated && vertical ? nsCSSValue(eCSSUnit_Unset) : *minWidth, pos->mMinWidth, parentPos->mMinWidth, SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); const nsCSSValue* maxWidth = aRuleData->ValueForMaxWidth(); if (maxWidth->GetUnit() == eCSSUnit_Enumerated) { conditions.SetWritingModeDependency(wm.GetBits()); } SetCoord(maxWidth->GetUnit() == eCSSUnit_Enumerated && vertical ? nsCSSValue(eCSSUnit_Unset) : *maxWidth, pos->mMaxWidth, parentPos->mMaxWidth, SETCOORD_LPOEH | SETCOORD_INITIAL_NONE | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); const nsCSSValue* height = aRuleData->ValueForHeight(); if (height->GetUnit() == eCSSUnit_Enumerated) { conditions.SetWritingModeDependency(wm.GetBits()); } SetCoord(height->GetUnit() == eCSSUnit_Enumerated && !vertical ? nsCSSValue(eCSSUnit_Unset) : *height, pos->mHeight, parentPos->mHeight, SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); const nsCSSValue* minHeight = aRuleData->ValueForMinHeight(); if (minHeight->GetUnit() == eCSSUnit_Enumerated) { conditions.SetWritingModeDependency(wm.GetBits()); } SetCoord(minHeight->GetUnit() == eCSSUnit_Enumerated && !vertical ? nsCSSValue(eCSSUnit_Unset) : *minHeight, pos->mMinHeight, parentPos->mMinHeight, SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); const nsCSSValue* maxHeight = aRuleData->ValueForMaxHeight(); if (maxHeight->GetUnit() == eCSSUnit_Enumerated) { conditions.SetWritingModeDependency(wm.GetBits()); } SetCoord(maxHeight->GetUnit() == eCSSUnit_Enumerated && !vertical ? nsCSSValue(eCSSUnit_Unset) : *maxHeight, pos->mMaxHeight, parentPos->mMaxHeight, SETCOORD_LPOEH | SETCOORD_INITIAL_NONE | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); // box-sizing: enum, inherit, initial SetValue(*aRuleData->ValueForBoxSizing(), pos->mBoxSizing, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mBoxSizing, StyleBoxSizing::Content); // align-content: enum, inherit, initial SetValue(*aRuleData->ValueForAlignContent(), pos->mAlignContent, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mAlignContent, NS_STYLE_ALIGN_NORMAL); // align-items: enum, inherit, initial SetValue(*aRuleData->ValueForAlignItems(), pos->mAlignItems, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mAlignItems, NS_STYLE_ALIGN_NORMAL); // align-self: enum, inherit, initial SetValue(*aRuleData->ValueForAlignSelf(), pos->mAlignSelf, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mAlignSelf, NS_STYLE_ALIGN_AUTO); // justify-content: enum, inherit, initial SetValue(*aRuleData->ValueForJustifyContent(), pos->mJustifyContent, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mJustifyContent, NS_STYLE_JUSTIFY_NORMAL); // justify-items: enum, inherit, initial const auto& justifyItemsValue = *aRuleData->ValueForJustifyItems(); if (MOZ_UNLIKELY(justifyItemsValue.GetUnit() == eCSSUnit_Inherit)) { if (MOZ_LIKELY(parentContext)) { pos->mJustifyItems = parentPos->ComputedJustifyItems(parentContext->GetParent()); } else { pos->mJustifyItems = NS_STYLE_JUSTIFY_NORMAL; } conditions.SetUncacheable(); } else { SetValue(justifyItemsValue, pos->mJustifyItems, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mJustifyItems, // unused, we handle 'inherit' above NS_STYLE_JUSTIFY_AUTO); } // justify-self: enum, inherit, initial SetValue(*aRuleData->ValueForJustifySelf(), pos->mJustifySelf, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mJustifySelf, NS_STYLE_JUSTIFY_AUTO); // flex-basis: auto, length, percent, enum, calc, inherit, initial // (Note: The flags here should match those used for 'width' property above.) SetCoord(*aRuleData->ValueForFlexBasis(), pos->mFlexBasis, parentPos->mFlexBasis, SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); // flex-direction: enum, inherit, initial SetValue(*aRuleData->ValueForFlexDirection(), pos->mFlexDirection, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mFlexDirection, NS_STYLE_FLEX_DIRECTION_ROW); // flex-grow: float, inherit, initial SetFactor(*aRuleData->ValueForFlexGrow(), pos->mFlexGrow, conditions, parentPos->mFlexGrow, 0.0f, SETFCT_UNSET_INITIAL); // flex-shrink: float, inherit, initial SetFactor(*aRuleData->ValueForFlexShrink(), pos->mFlexShrink, conditions, parentPos->mFlexShrink, 1.0f, SETFCT_UNSET_INITIAL); // flex-wrap: enum, inherit, initial SetValue(*aRuleData->ValueForFlexWrap(), pos->mFlexWrap, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mFlexWrap, NS_STYLE_FLEX_WRAP_NOWRAP); // order: integer, inherit, initial SetValue(*aRuleData->ValueForOrder(), pos->mOrder, conditions, SETVAL_INTEGER | SETVAL_UNSET_INITIAL, parentPos->mOrder, NS_STYLE_ORDER_INITIAL); // object-fit: enum, inherit, initial SetValue(*aRuleData->ValueForObjectFit(), pos->mObjectFit, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentPos->mObjectFit, NS_STYLE_OBJECT_FIT_FILL); // object-position const nsCSSValue& objectPosition = *aRuleData->ValueForObjectPosition(); switch (objectPosition.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: conditions.SetUncacheable(); pos->mObjectPosition = parentPos->mObjectPosition; break; case eCSSUnit_Initial: case eCSSUnit_Unset: pos->mObjectPosition.SetInitialPercentValues(0.5f); break; default: ComputePositionValue(aContext, objectPosition, pos->mObjectPosition, conditions); } // grid-auto-flow const nsCSSValue& gridAutoFlow = *aRuleData->ValueForGridAutoFlow(); switch (gridAutoFlow.GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: conditions.SetUncacheable(); pos->mGridAutoFlow = parentPos->mGridAutoFlow; break; case eCSSUnit_Initial: case eCSSUnit_Unset: pos->mGridAutoFlow = NS_STYLE_GRID_AUTO_FLOW_ROW; break; default: NS_ASSERTION(gridAutoFlow.GetUnit() == eCSSUnit_Enumerated, "Unexpected unit"); pos->mGridAutoFlow = gridAutoFlow.GetIntValue(); } // grid-auto-columns SetGridAutoColumnsRows(*aRuleData->ValueForGridAutoColumns(), pos->mGridAutoColumnsMin, pos->mGridAutoColumnsMax, parentPos->mGridAutoColumnsMin, parentPos->mGridAutoColumnsMax, aContext, mPresContext, conditions); // grid-auto-rows SetGridAutoColumnsRows(*aRuleData->ValueForGridAutoRows(), pos->mGridAutoRowsMin, pos->mGridAutoRowsMax, parentPos->mGridAutoRowsMin, parentPos->mGridAutoRowsMax, aContext, mPresContext, conditions); // grid-template-columns SetGridTrackList(*aRuleData->ValueForGridTemplateColumns(), pos->mGridTemplateColumns, parentPos->mGridTemplateColumns, aContext, mPresContext, conditions); // grid-template-rows SetGridTrackList(*aRuleData->ValueForGridTemplateRows(), pos->mGridTemplateRows, parentPos->mGridTemplateRows, aContext, mPresContext, conditions); // grid-tempate-areas SetGridTemplateAreas(*aRuleData->ValueForGridTemplateAreas(), &pos->mGridTemplateAreas, parentPos->mGridTemplateAreas, conditions); // grid-column-start SetGridLine(*aRuleData->ValueForGridColumnStart(), pos->mGridColumnStart, parentPos->mGridColumnStart, conditions); // grid-column-end SetGridLine(*aRuleData->ValueForGridColumnEnd(), pos->mGridColumnEnd, parentPos->mGridColumnEnd, conditions); // grid-row-start SetGridLine(*aRuleData->ValueForGridRowStart(), pos->mGridRowStart, parentPos->mGridRowStart, conditions); // grid-row-end SetGridLine(*aRuleData->ValueForGridRowEnd(), pos->mGridRowEnd, parentPos->mGridRowEnd, conditions); // grid-column-gap if (SetCoord(*aRuleData->ValueForGridColumnGap(), pos->mGridColumnGap, parentPos->mGridColumnGap, SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_CALC_CLAMP_NONNEGATIVE | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { } else { MOZ_ASSERT(aRuleData->ValueForGridColumnGap()->GetUnit() == eCSSUnit_Null, "unexpected unit"); } // grid-row-gap if (SetCoord(*aRuleData->ValueForGridRowGap(), pos->mGridRowGap, parentPos->mGridRowGap, SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC | SETCOORD_CALC_CLAMP_NONNEGATIVE | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions)) { } else { MOZ_ASSERT(aRuleData->ValueForGridRowGap()->GetUnit() == eCSSUnit_Null, "unexpected unit"); } // z-index const nsCSSValue* zIndexValue = aRuleData->ValueForZIndex(); if (! SetCoord(*zIndexValue, pos->mZIndex, parentPos->mZIndex, SETCOORD_IA | SETCOORD_INITIAL_AUTO | SETCOORD_UNSET_INITIAL, aContext, nullptr, conditions)) { if (eCSSUnit_Inherit == zIndexValue->GetUnit()) { // handle inherit, because it's ok to inherit 'auto' here conditions.SetUncacheable(); pos->mZIndex = parentPos->mZIndex; } } COMPUTE_END_RESET(Position, pos) } const void* nsRuleNode::ComputeTableData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Table, table, parentTable) // table-layout: enum, inherit, initial SetValue(*aRuleData->ValueForTableLayout(), table->mLayoutStrategy, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentTable->mLayoutStrategy, NS_STYLE_TABLE_LAYOUT_AUTO); // span: pixels (not a real CSS prop) const nsCSSValue* spanValue = aRuleData->ValueForSpan(); if (eCSSUnit_Enumerated == spanValue->GetUnit() || eCSSUnit_Integer == spanValue->GetUnit()) table->mSpan = spanValue->GetIntValue(); COMPUTE_END_RESET(Table, table) } const void* nsRuleNode::ComputeTableBorderData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(TableBorder, table, parentTable) // border-collapse: enum, inherit, initial SetValue(*aRuleData->ValueForBorderCollapse(), table->mBorderCollapse, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentTable->mBorderCollapse, NS_STYLE_BORDER_SEPARATE); const nsCSSValue* borderSpacingValue = aRuleData->ValueForBorderSpacing(); // border-spacing: pair(length), inherit if (borderSpacingValue->GetUnit() != eCSSUnit_Null) { nsStyleCoord parentCol(parentTable->mBorderSpacingCol, nsStyleCoord::CoordConstructor); nsStyleCoord parentRow(parentTable->mBorderSpacingRow, nsStyleCoord::CoordConstructor); nsStyleCoord coordCol, coordRow; #ifdef DEBUG bool result = #endif SetPairCoords(*borderSpacingValue, coordCol, coordRow, parentCol, parentRow, SETCOORD_LH | SETCOORD_INITIAL_ZERO | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_CALC_CLAMP_NONNEGATIVE | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); NS_ASSERTION(result, "malformed table border value"); table->mBorderSpacingCol = coordCol.GetCoordValue(); table->mBorderSpacingRow = coordRow.GetCoordValue(); } // caption-side: enum, inherit, initial SetValue(*aRuleData->ValueForCaptionSide(), table->mCaptionSide, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentTable->mCaptionSide, NS_STYLE_CAPTION_SIDE_TOP); // empty-cells: enum, inherit, initial SetValue(*aRuleData->ValueForEmptyCells(), table->mEmptyCells, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentTable->mEmptyCells, NS_STYLE_TABLE_EMPTY_CELLS_SHOW); COMPUTE_END_INHERITED(TableBorder, table) } const void* nsRuleNode::ComputeContentData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { uint32_t count; nsAutoString buffer; COMPUTE_START_RESET(Content, content, parentContent) // content: [string, url, counter, attr, enum]+, normal, none, inherit const nsCSSValue* contentValue = aRuleData->ValueForContent(); switch (contentValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Normal: case eCSSUnit_None: case eCSSUnit_Initial: case eCSSUnit_Unset: // "normal", "none", "initial" and "unset" all mean no content content->AllocateContents(0); break; case eCSSUnit_Inherit: conditions.SetUncacheable(); count = parentContent->ContentCount(); content->AllocateContents(count); while (0 < count--) { content->ContentAt(count) = parentContent->ContentAt(count); } break; case eCSSUnit_Enumerated: { MOZ_ASSERT(contentValue->GetIntValue() == NS_STYLE_CONTENT_ALT_CONTENT, "unrecognized solitary content keyword"); content->AllocateContents(1); nsStyleContentData& data = content->ContentAt(0); data.mType = eStyleContentType_AltContent; data.mContent.mString = nullptr; break; } case eCSSUnit_List: case eCSSUnit_ListDep: { const nsCSSValueList* contentValueList = contentValue->GetListValue(); count = 0; while (contentValueList) { count++; contentValueList = contentValueList->mNext; } content->AllocateContents(count); const nsAutoString nullStr; count = 0; contentValueList = contentValue->GetListValue(); while (contentValueList) { const nsCSSValue& value = contentValueList->mValue; nsCSSUnit unit = value.GetUnit(); nsStyleContentType type; nsStyleContentData &data = content->ContentAt(count++); switch (unit) { case eCSSUnit_String: type = eStyleContentType_String; break; case eCSSUnit_Image: type = eStyleContentType_Image; break; case eCSSUnit_Attr: type = eStyleContentType_Attr; break; case eCSSUnit_Counter: type = eStyleContentType_Counter; break; case eCSSUnit_Counters: type = eStyleContentType_Counters; break; case eCSSUnit_Enumerated: switch (value.GetIntValue()) { case NS_STYLE_CONTENT_OPEN_QUOTE: type = eStyleContentType_OpenQuote; break; case NS_STYLE_CONTENT_CLOSE_QUOTE: type = eStyleContentType_CloseQuote; break; case NS_STYLE_CONTENT_NO_OPEN_QUOTE: type = eStyleContentType_NoOpenQuote; break; case NS_STYLE_CONTENT_NO_CLOSE_QUOTE: type = eStyleContentType_NoCloseQuote; break; default: NS_ERROR("bad content value"); type = eStyleContentType_Uninitialized; } break; default: NS_ERROR("bad content type"); type = eStyleContentType_Uninitialized; } data.mType = type; if (type == eStyleContentType_Image) { SetImageRequest([&](imgRequestProxy* req) { data.SetImage(req); }, mPresContext, value); } else if (type <= eStyleContentType_Attr) { value.GetStringValue(buffer); data.mContent.mString = NS_strdup(buffer.get()); } else if (type <= eStyleContentType_Counters) { data.mContent.mCounters = value.GetArrayValue(); data.mContent.mCounters->AddRef(); } else { data.mContent.mString = nullptr; } contentValueList = contentValueList->mNext; } break; } default: MOZ_ASSERT(false, "unrecognized content unit"); } // counter-increment: [string [int]]+, none, inherit const nsCSSValue* counterIncrementValue = aRuleData->ValueForCounterIncrement(); switch (counterIncrementValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_None: case eCSSUnit_Initial: case eCSSUnit_Unset: content->AllocateCounterIncrements(0); break; case eCSSUnit_Inherit: conditions.SetUncacheable(); count = parentContent->CounterIncrementCount(); content->AllocateCounterIncrements(count); while (count--) { const nsStyleCounterData& data = parentContent->CounterIncrementAt(count); content->SetCounterIncrementAt(count, data.mCounter, data.mValue); } break; case eCSSUnit_PairList: case eCSSUnit_PairListDep: { const nsCSSValuePairList* ourIncrement = counterIncrementValue->GetPairListValue(); MOZ_ASSERT(ourIncrement->mXValue.GetUnit() == eCSSUnit_Ident, "unexpected value unit"); count = ListLength(ourIncrement); content->AllocateCounterIncrements(count); count = 0; for (const nsCSSValuePairList* p = ourIncrement; p; p = p->mNext, count++) { int32_t increment; if (p->mYValue.GetUnit() == eCSSUnit_Integer) { increment = p->mYValue.GetIntValue(); } else { increment = 1; } p->mXValue.GetStringValue(buffer); content->SetCounterIncrementAt(count, buffer, increment); } break; } default: MOZ_ASSERT(false, "unexpected value unit"); } // counter-reset: [string [int]]+, none, inherit const nsCSSValue* counterResetValue = aRuleData->ValueForCounterReset(); switch (counterResetValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_None: case eCSSUnit_Initial: case eCSSUnit_Unset: content->AllocateCounterResets(0); break; case eCSSUnit_Inherit: conditions.SetUncacheable(); count = parentContent->CounterResetCount(); content->AllocateCounterResets(count); while (0 < count--) { const nsStyleCounterData& data = parentContent->CounterResetAt(count); content->SetCounterResetAt(count, data.mCounter, data.mValue); } break; case eCSSUnit_PairList: case eCSSUnit_PairListDep: { const nsCSSValuePairList* ourReset = counterResetValue->GetPairListValue(); MOZ_ASSERT(ourReset->mXValue.GetUnit() == eCSSUnit_Ident, "unexpected value unit"); count = ListLength(ourReset); content->AllocateCounterResets(count); count = 0; for (const nsCSSValuePairList* p = ourReset; p; p = p->mNext, count++) { int32_t reset; if (p->mYValue.GetUnit() == eCSSUnit_Integer) { reset = p->mYValue.GetIntValue(); } else { reset = 0; } p->mXValue.GetStringValue(buffer); content->SetCounterResetAt(count, buffer, reset); } break; } default: MOZ_ASSERT(false, "unexpected value unit"); } // If we ended up with an image, track it. for (uint32_t i = 0; i < content->ContentCount(); ++i) { if ((content->ContentAt(i).mType == eStyleContentType_Image) && content->ContentAt(i).mContent.mImage) { content->ContentAt(i).TrackImage( aContext->PresContext()->Document()->ImageTracker()); } } COMPUTE_END_RESET(Content, content) } const void* nsRuleNode::ComputeXULData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(XUL, xul, parentXUL) // box-align: enum, inherit, initial SetValue(*aRuleData->ValueForBoxAlign(), xul->mBoxAlign, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentXUL->mBoxAlign, StyleBoxAlign::Stretch); // box-direction: enum, inherit, initial SetValue(*aRuleData->ValueForBoxDirection(), xul->mBoxDirection, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentXUL->mBoxDirection, StyleBoxDirection::Normal); // box-flex: factor, inherit SetFactor(*aRuleData->ValueForBoxFlex(), xul->mBoxFlex, conditions, parentXUL->mBoxFlex, 0.0f, SETFCT_UNSET_INITIAL); // box-orient: enum, inherit, initial SetValue(*aRuleData->ValueForBoxOrient(), xul->mBoxOrient, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentXUL->mBoxOrient, StyleBoxOrient::Horizontal); // box-pack: enum, inherit, initial SetValue(*aRuleData->ValueForBoxPack(), xul->mBoxPack, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentXUL->mBoxPack, StyleBoxPack::Start); // box-ordinal-group: integer, inherit, initial SetValue(*aRuleData->ValueForBoxOrdinalGroup(), xul->mBoxOrdinal, conditions, SETVAL_INTEGER | SETVAL_UNSET_INITIAL, parentXUL->mBoxOrdinal, 1); const nsCSSValue* stackSizingValue = aRuleData->ValueForStackSizing(); if (eCSSUnit_Inherit == stackSizingValue->GetUnit()) { conditions.SetUncacheable(); xul->mStretchStack = parentXUL->mStretchStack; } else if (eCSSUnit_Initial == stackSizingValue->GetUnit() || eCSSUnit_Unset == stackSizingValue->GetUnit()) { xul->mStretchStack = true; } else if (eCSSUnit_Enumerated == stackSizingValue->GetUnit()) { xul->mStretchStack = stackSizingValue->GetIntValue() == NS_STYLE_STACK_SIZING_STRETCH_TO_FIT; } COMPUTE_END_RESET(XUL, xul) } const void* nsRuleNode::ComputeColumnData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Column, column, parent) // column-width: length, auto, inherit SetCoord(*aRuleData->ValueForColumnWidth(), column->mColumnWidth, parent->mColumnWidth, SETCOORD_LAH | SETCOORD_INITIAL_AUTO | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_CALC_CLAMP_NONNEGATIVE | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); // column-gap: length, inherit, normal SetCoord(*aRuleData->ValueForColumnGap(), column->mColumnGap, parent->mColumnGap, SETCOORD_LH | SETCOORD_NORMAL | SETCOORD_INITIAL_NORMAL | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INITIAL, aContext, mPresContext, conditions); // clamp negative calc() to 0 if (column->mColumnGap.GetUnit() == eStyleUnit_Coord) { column->mColumnGap.SetCoordValue( std::max(column->mColumnGap.GetCoordValue(), 0)); } // column-count: auto, integer, inherit const nsCSSValue* columnCountValue = aRuleData->ValueForColumnCount(); if (eCSSUnit_Auto == columnCountValue->GetUnit() || eCSSUnit_Initial == columnCountValue->GetUnit() || eCSSUnit_Unset == columnCountValue->GetUnit()) { column->mColumnCount = NS_STYLE_COLUMN_COUNT_AUTO; } else if (eCSSUnit_Integer == columnCountValue->GetUnit()) { column->mColumnCount = columnCountValue->GetIntValue(); // Max kMaxColumnCount columns - wallpaper for bug 345583. column->mColumnCount = std::min(column->mColumnCount, nsStyleColumn::kMaxColumnCount); } else if (eCSSUnit_Inherit == columnCountValue->GetUnit()) { conditions.SetUncacheable(); column->mColumnCount = parent->mColumnCount; } // column-rule-width: length, enum, inherit const nsCSSValue& widthValue = *aRuleData->ValueForColumnRuleWidth(); if (eCSSUnit_Initial == widthValue.GetUnit() || eCSSUnit_Unset == widthValue.GetUnit()) { column->SetColumnRuleWidth( (mPresContext->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM]); } else if (eCSSUnit_Enumerated == widthValue.GetUnit()) { NS_ASSERTION(widthValue.GetIntValue() == NS_STYLE_BORDER_WIDTH_THIN || widthValue.GetIntValue() == NS_STYLE_BORDER_WIDTH_MEDIUM || widthValue.GetIntValue() == NS_STYLE_BORDER_WIDTH_THICK, "Unexpected enum value"); column->SetColumnRuleWidth( (mPresContext->GetBorderWidthTable())[widthValue.GetIntValue()]); } else if (eCSSUnit_Inherit == widthValue.GetUnit()) { column->SetColumnRuleWidth(parent->GetComputedColumnRuleWidth()); conditions.SetUncacheable(); } else if (widthValue.IsLengthUnit() || widthValue.IsCalcUnit()) { nscoord len = CalcLength(widthValue, aContext, mPresContext, conditions); if (len < 0) { // FIXME: This is untested (by test_value_storage.html) for // column-rule-width since it gets covered up by the border // rounding code. NS_ASSERTION(widthValue.IsCalcUnit(), "parser should have rejected negative length"); len = 0; } column->SetColumnRuleWidth(len); } // column-rule-style: enum, inherit const nsCSSValue& styleValue = *aRuleData->ValueForColumnRuleStyle(); MOZ_ASSERT(eCSSUnit_None != styleValue.GetUnit(), "'none' should be handled as enumerated value"); if (eCSSUnit_Enumerated == styleValue.GetUnit()) { column->mColumnRuleStyle = styleValue.GetIntValue(); } else if (eCSSUnit_Initial == styleValue.GetUnit() || eCSSUnit_Unset == styleValue.GetUnit()) { column->mColumnRuleStyle = NS_STYLE_BORDER_STYLE_NONE; } else if (eCSSUnit_Inherit == styleValue.GetUnit()) { conditions.SetUncacheable(); column->mColumnRuleStyle = parent->mColumnRuleStyle; } // column-rule-color: color, inherit SetComplexColor<eUnsetInitial>(*aRuleData->ValueForColumnRuleColor(), parent->mColumnRuleColor, StyleComplexColor::CurrentColor(), mPresContext, column->mColumnRuleColor, conditions); // column-fill: enum SetValue(*aRuleData->ValueForColumnFill(), column->mColumnFill, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parent->mColumnFill, NS_STYLE_COLUMN_FILL_BALANCE); COMPUTE_END_RESET(Column, column) } static void SetSVGPaint(const nsCSSValue& aValue, const nsStyleSVGPaint& parentPaint, nsPresContext* aPresContext, nsStyleContext *aContext, nsStyleSVGPaint& aResult, nsStyleSVGPaintType aInitialPaintType, RuleNodeCacheConditions& aConditions) { MOZ_ASSERT(aInitialPaintType == eStyleSVGPaintType_None || aInitialPaintType == eStyleSVGPaintType_Color, "SetSVGPaint only supports initial values being either 'black' " "(represented by eStyleSVGPaintType_Color) or none (by " "eStyleSVGPaintType_None)"); nscolor color; if (aValue.GetUnit() == eCSSUnit_Inherit || aValue.GetUnit() == eCSSUnit_Unset) { aResult = parentPaint; aConditions.SetUncacheable(); } else if (aValue.GetUnit() == eCSSUnit_None) { aResult.SetNone(); } else if (aValue.GetUnit() == eCSSUnit_Initial) { if (aInitialPaintType == eStyleSVGPaintType_None) { aResult.SetNone(); } else { aResult.SetColor(NS_RGB(0, 0, 0)); } } else if (SetColor(aValue, NS_RGB(0, 0, 0), aPresContext, aContext, color, aConditions)) { aResult.SetColor(color); } else if (aValue.GetUnit() == eCSSUnit_Pair) { const nsCSSValuePair& pair = aValue.GetPairValue(); nscolor fallback; if (pair.mYValue.GetUnit() == eCSSUnit_None) { fallback = NS_RGBA(0, 0, 0, 0); } else { MOZ_ASSERT(pair.mYValue.GetUnit() != eCSSUnit_Inherit, "cannot inherit fallback colour"); SetColor(pair.mYValue, NS_RGB(0, 0, 0), aPresContext, aContext, fallback, aConditions); } if (pair.mXValue.GetUnit() == eCSSUnit_URL) { aResult.SetPaintServer(pair.mXValue.GetURLStructValue(), fallback); } else if (pair.mXValue.GetUnit() == eCSSUnit_Enumerated) { switch (pair.mXValue.GetIntValue()) { case NS_COLOR_CONTEXT_FILL: aResult.SetContextValue(eStyleSVGPaintType_ContextFill, fallback); break; case NS_COLOR_CONTEXT_STROKE: aResult.SetContextValue(eStyleSVGPaintType_ContextStroke, fallback); break; default: NS_NOTREACHED("unknown keyword as paint server value"); } } else { NS_NOTREACHED("malformed paint server value"); } } else { MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Null, "malformed paint server value"); } } static void SetSVGOpacity(const nsCSSValue& aValue, float& aOpacityField, nsStyleSVGOpacitySource& aOpacityTypeField, RuleNodeCacheConditions& aConditions, float aParentOpacity, nsStyleSVGOpacitySource aParentOpacityType) { if (eCSSUnit_Enumerated == aValue.GetUnit()) { switch (aValue.GetIntValue()) { case NS_STYLE_CONTEXT_FILL_OPACITY: aOpacityTypeField = eStyleSVGOpacitySource_ContextFillOpacity; break; case NS_STYLE_CONTEXT_STROKE_OPACITY: aOpacityTypeField = eStyleSVGOpacitySource_ContextStrokeOpacity; break; default: NS_NOTREACHED("SetSVGOpacity: Unknown keyword"); } // Fall back on fully opaque aOpacityField = 1.0f; } else if (eCSSUnit_Inherit == aValue.GetUnit() || eCSSUnit_Unset == aValue.GetUnit()) { aConditions.SetUncacheable(); aOpacityField = aParentOpacity; aOpacityTypeField = aParentOpacityType; } else if (eCSSUnit_Null != aValue.GetUnit()) { SetFactor(aValue, aOpacityField, aConditions, aParentOpacity, 1.0f, SETFCT_OPACITY); aOpacityTypeField = eStyleSVGOpacitySource_Normal; } } /* static */ void nsRuleNode::FillAllMaskLists(nsStyleImageLayers& aMask, uint32_t aMaxItemCount) { // Delete any extra items. We need to keep layers in which any // property was specified. aMask.mLayers.TruncateLengthNonZero(aMaxItemCount); uint32_t fillCount = aMask.mImageCount; FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mImage, aMask.mImageCount, fillCount); FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mSourceURI, aMask.mImageCount, fillCount); FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mRepeat, aMask.mRepeatCount, fillCount); FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mClip, aMask.mClipCount, fillCount); FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mOrigin, aMask.mOriginCount, fillCount); FillImageLayerPositionCoordList(aMask.mLayers, &Position::mXPosition, aMask.mPositionXCount, fillCount); FillImageLayerPositionCoordList(aMask.mLayers, &Position::mYPosition, aMask.mPositionYCount, fillCount); FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mSize, aMask.mSizeCount, fillCount); FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mMaskMode, aMask.mMaskModeCount, fillCount); FillImageLayerList(aMask.mLayers, &nsStyleImageLayers::Layer::mComposite, aMask.mCompositeCount, fillCount); } const void* nsRuleNode::ComputeSVGData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(SVG, svg, parentSVG) // clip-rule: enum, inherit, initial SetValue(*aRuleData->ValueForClipRule(), svg->mClipRule, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mClipRule, StyleFillRule::Nonzero); // color-interpolation: enum, inherit, initial SetValue(*aRuleData->ValueForColorInterpolation(), svg->mColorInterpolation, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mColorInterpolation, NS_STYLE_COLOR_INTERPOLATION_SRGB); // color-interpolation-filters: enum, inherit, initial SetValue(*aRuleData->ValueForColorInterpolationFilters(), svg->mColorInterpolationFilters, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mColorInterpolationFilters, NS_STYLE_COLOR_INTERPOLATION_LINEARRGB); // fill: SetSVGPaint(*aRuleData->ValueForFill(), parentSVG->mFill, mPresContext, aContext, svg->mFill, eStyleSVGPaintType_Color, conditions); // fill-opacity: factor, inherit, initial, // context-fill-opacity, context-stroke-opacity nsStyleSVGOpacitySource contextFillOpacity = svg->FillOpacitySource(); SetSVGOpacity(*aRuleData->ValueForFillOpacity(), svg->mFillOpacity, contextFillOpacity, conditions, parentSVG->mFillOpacity, parentSVG->FillOpacitySource()); svg->SetFillOpacitySource(contextFillOpacity); // fill-rule: enum, inherit, initial SetValue(*aRuleData->ValueForFillRule(), svg->mFillRule, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mFillRule, StyleFillRule::Nonzero); // marker-end: url, none, inherit const nsCSSValue* markerEndValue = aRuleData->ValueForMarkerEnd(); if (eCSSUnit_URL == markerEndValue->GetUnit()) { svg->mMarkerEnd = markerEndValue->GetURLStructValue(); } else if (eCSSUnit_None == markerEndValue->GetUnit() || eCSSUnit_Initial == markerEndValue->GetUnit()) { svg->mMarkerEnd = nullptr; } else if (eCSSUnit_Inherit == markerEndValue->GetUnit() || eCSSUnit_Unset == markerEndValue->GetUnit()) { conditions.SetUncacheable(); svg->mMarkerEnd = parentSVG->mMarkerEnd; } // marker-mid: url, none, inherit const nsCSSValue* markerMidValue = aRuleData->ValueForMarkerMid(); if (eCSSUnit_URL == markerMidValue->GetUnit()) { svg->mMarkerMid = markerMidValue->GetURLStructValue(); } else if (eCSSUnit_None == markerMidValue->GetUnit() || eCSSUnit_Initial == markerMidValue->GetUnit()) { svg->mMarkerMid = nullptr; } else if (eCSSUnit_Inherit == markerMidValue->GetUnit() || eCSSUnit_Unset == markerMidValue->GetUnit()) { conditions.SetUncacheable(); svg->mMarkerMid = parentSVG->mMarkerMid; } // marker-start: url, none, inherit const nsCSSValue* markerStartValue = aRuleData->ValueForMarkerStart(); if (eCSSUnit_URL == markerStartValue->GetUnit()) { svg->mMarkerStart = markerStartValue->GetURLStructValue(); } else if (eCSSUnit_None == markerStartValue->GetUnit() || eCSSUnit_Initial == markerStartValue->GetUnit()) { svg->mMarkerStart = nullptr; } else if (eCSSUnit_Inherit == markerStartValue->GetUnit() || eCSSUnit_Unset == markerStartValue->GetUnit()) { conditions.SetUncacheable(); svg->mMarkerStart = parentSVG->mMarkerStart; } // paint-order: enum (bit field), inherit, initial const nsCSSValue* paintOrderValue = aRuleData->ValueForPaintOrder(); switch (paintOrderValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Enumerated: static_assert (NS_STYLE_PAINT_ORDER_BITWIDTH * NS_STYLE_PAINT_ORDER_LAST_VALUE <= 8, "SVGStyleStruct::mPaintOrder not big enough"); svg->mPaintOrder = static_cast<uint8_t>(paintOrderValue->GetIntValue()); break; case eCSSUnit_Inherit: case eCSSUnit_Unset: conditions.SetUncacheable(); svg->mPaintOrder = parentSVG->mPaintOrder; break; case eCSSUnit_Initial: svg->mPaintOrder = NS_STYLE_PAINT_ORDER_NORMAL; break; default: NS_NOTREACHED("unexpected unit"); } // shape-rendering: enum, inherit SetValue(*aRuleData->ValueForShapeRendering(), svg->mShapeRendering, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mShapeRendering, NS_STYLE_SHAPE_RENDERING_AUTO); // stroke: SetSVGPaint(*aRuleData->ValueForStroke(), parentSVG->mStroke, mPresContext, aContext, svg->mStroke, eStyleSVGPaintType_None, conditions); // stroke-dasharray: <dasharray>, none, inherit, context-value const nsCSSValue* strokeDasharrayValue = aRuleData->ValueForStrokeDasharray(); switch (strokeDasharrayValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Inherit: case eCSSUnit_Unset: conditions.SetUncacheable(); svg->SetStrokeDasharrayFromObject(parentSVG->StrokeDasharrayFromObject()); svg->mStrokeDasharray = parentSVG->mStrokeDasharray; break; case eCSSUnit_Enumerated: MOZ_ASSERT(strokeDasharrayValue->GetIntValue() == NS_STYLE_STROKE_PROP_CONTEXT_VALUE, "Unknown keyword for stroke-dasharray"); svg->SetStrokeDasharrayFromObject(true); svg->mStrokeDasharray.Clear(); break; case eCSSUnit_Initial: case eCSSUnit_None: svg->SetStrokeDasharrayFromObject(false); svg->mStrokeDasharray.Clear(); break; case eCSSUnit_List: case eCSSUnit_ListDep: { svg->SetStrokeDasharrayFromObject(false); svg->mStrokeDasharray.Clear(); // count number of values const nsCSSValueList *value = strokeDasharrayValue->GetListValue(); uint32_t strokeDasharrayLength = ListLength(value); MOZ_ASSERT(strokeDasharrayLength != 0, "no dasharray items"); svg->mStrokeDasharray.SetLength(strokeDasharrayLength); uint32_t i = 0; while (nullptr != value) { SetCoord(value->mValue, svg->mStrokeDasharray[i++], nsStyleCoord(), SETCOORD_LP | SETCOORD_FACTOR, aContext, mPresContext, conditions); value = value->mNext; } break; } default: MOZ_ASSERT(false, "unrecognized dasharray unit"); } // stroke-dashoffset: <dashoffset>, inherit const nsCSSValue *strokeDashoffsetValue = aRuleData->ValueForStrokeDashoffset(); svg->SetStrokeDashoffsetFromObject( strokeDashoffsetValue->GetUnit() == eCSSUnit_Enumerated && strokeDashoffsetValue->GetIntValue() == NS_STYLE_STROKE_PROP_CONTEXT_VALUE); if (svg->StrokeDashoffsetFromObject()) { svg->mStrokeDashoffset.SetCoordValue(0); } else { SetCoord(*aRuleData->ValueForStrokeDashoffset(), svg->mStrokeDashoffset, parentSVG->mStrokeDashoffset, SETCOORD_LPH | SETCOORD_FACTOR | SETCOORD_INITIAL_ZERO | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); } // stroke-linecap: enum, inherit, initial SetValue(*aRuleData->ValueForStrokeLinecap(), svg->mStrokeLinecap, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mStrokeLinecap, NS_STYLE_STROKE_LINECAP_BUTT); // stroke-linejoin: enum, inherit, initial SetValue(*aRuleData->ValueForStrokeLinejoin(), svg->mStrokeLinejoin, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mStrokeLinejoin, NS_STYLE_STROKE_LINEJOIN_MITER); // stroke-miterlimit: <miterlimit>, inherit SetFactor(*aRuleData->ValueForStrokeMiterlimit(), svg->mStrokeMiterlimit, conditions, parentSVG->mStrokeMiterlimit, 4.0f, SETFCT_UNSET_INHERIT); // stroke-opacity: nsStyleSVGOpacitySource contextStrokeOpacity = svg->StrokeOpacitySource(); SetSVGOpacity(*aRuleData->ValueForStrokeOpacity(), svg->mStrokeOpacity, contextStrokeOpacity, conditions, parentSVG->mStrokeOpacity, parentSVG->StrokeOpacitySource()); svg->SetStrokeOpacitySource(contextStrokeOpacity); // stroke-width: const nsCSSValue* strokeWidthValue = aRuleData->ValueForStrokeWidth(); switch (strokeWidthValue->GetUnit()) { case eCSSUnit_Enumerated: MOZ_ASSERT(strokeWidthValue->GetIntValue() == NS_STYLE_STROKE_PROP_CONTEXT_VALUE, "Unrecognized keyword for stroke-width"); svg->SetStrokeWidthFromObject(true); svg->mStrokeWidth.SetCoordValue(nsPresContext::CSSPixelsToAppUnits(1)); break; case eCSSUnit_Initial: svg->SetStrokeWidthFromObject(false); svg->mStrokeWidth.SetCoordValue(nsPresContext::CSSPixelsToAppUnits(1)); break; default: svg->SetStrokeWidthFromObject(false); SetCoord(*strokeWidthValue, svg->mStrokeWidth, parentSVG->mStrokeWidth, SETCOORD_LPH | SETCOORD_FACTOR | SETCOORD_UNSET_INHERIT, aContext, mPresContext, conditions); } // text-anchor: enum, inherit, initial SetValue(*aRuleData->ValueForTextAnchor(), svg->mTextAnchor, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT, parentSVG->mTextAnchor, NS_STYLE_TEXT_ANCHOR_START); COMPUTE_END_INHERITED(SVG, svg) } static already_AddRefed<StyleBasicShape> GetStyleBasicShapeFromCSSValue(const nsCSSValue& aValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { RefPtr<StyleBasicShape> basicShape; nsCSSValue::Array* shapeFunction = aValue.GetArrayValue(); nsCSSKeyword functionName = (nsCSSKeyword)shapeFunction->Item(0).GetIntValue(); if (functionName == eCSSKeyword_polygon) { MOZ_ASSERT(!basicShape, "did not expect value"); basicShape = new StyleBasicShape(StyleBasicShapeType::Polygon); MOZ_ASSERT(shapeFunction->Count() > 1, "polygon has wrong number of arguments"); size_t j = 1; if (shapeFunction->Item(j).GetUnit() == eCSSUnit_Enumerated) { StyleFillRule rule; SetEnumValueHelper::SetEnumeratedValue(rule, shapeFunction->Item(j)); basicShape->SetFillRule(rule); ++j; } const int32_t mask = SETCOORD_PERCENT | SETCOORD_LENGTH | SETCOORD_STORE_CALC; const nsCSSValuePairList* curPair = shapeFunction->Item(j).GetPairListValue(); nsTArray<nsStyleCoord>& coordinates = basicShape->Coordinates(); while (curPair) { nsStyleCoord xCoord, yCoord; DebugOnly<bool> didSetCoordX = SetCoord(curPair->mXValue, xCoord, nsStyleCoord(), mask, aStyleContext, aPresContext, aConditions); coordinates.AppendElement(xCoord); MOZ_ASSERT(didSetCoordX, "unexpected x coordinate unit"); DebugOnly<bool> didSetCoordY = SetCoord(curPair->mYValue, yCoord, nsStyleCoord(), mask, aStyleContext, aPresContext, aConditions); coordinates.AppendElement(yCoord); MOZ_ASSERT(didSetCoordY, "unexpected y coordinate unit"); curPair = curPair->mNext; } } else if (functionName == eCSSKeyword_circle || functionName == eCSSKeyword_ellipse) { StyleBasicShapeType type = functionName == eCSSKeyword_circle ? StyleBasicShapeType::Circle : StyleBasicShapeType::Ellipse; MOZ_ASSERT(!basicShape, "did not expect value"); basicShape = new StyleBasicShape(type); const int32_t mask = SETCOORD_PERCENT | SETCOORD_LENGTH | SETCOORD_STORE_CALC | SETCOORD_ENUMERATED; size_t count = type == StyleBasicShapeType::Circle ? 2 : 3; MOZ_ASSERT(shapeFunction->Count() == count + 1, "unexpected arguments count"); MOZ_ASSERT(type == StyleBasicShapeType::Circle || (shapeFunction->Item(1).GetUnit() == eCSSUnit_Null) == (shapeFunction->Item(2).GetUnit() == eCSSUnit_Null), "ellipse should have two radii or none"); for (size_t j = 1; j < count; ++j) { const nsCSSValue& val = shapeFunction->Item(j); nsStyleCoord radius; if (val.GetUnit() != eCSSUnit_Null) { DebugOnly<bool> didSetRadius = SetCoord(val, radius, nsStyleCoord(), mask, aStyleContext, aPresContext, aConditions); MOZ_ASSERT(didSetRadius, "unexpected radius unit"); } else { radius.SetIntValue(NS_RADIUS_CLOSEST_SIDE, eStyleUnit_Enumerated); } basicShape->Coordinates().AppendElement(radius); } const nsCSSValue& positionVal = shapeFunction->Item(count); if (positionVal.GetUnit() == eCSSUnit_Array) { ComputePositionValue(aStyleContext, positionVal, basicShape->GetPosition(), aConditions); } else { MOZ_ASSERT(positionVal.GetUnit() == eCSSUnit_Null, "expected no value"); } } else if (functionName == eCSSKeyword_inset) { MOZ_ASSERT(!basicShape, "did not expect value"); basicShape = new StyleBasicShape(StyleBasicShapeType::Inset); MOZ_ASSERT(shapeFunction->Count() == 6, "inset function has wrong number of arguments"); MOZ_ASSERT(shapeFunction->Item(1).GetUnit() != eCSSUnit_Null, "no shape arguments defined"); const int32_t mask = SETCOORD_PERCENT | SETCOORD_LENGTH | SETCOORD_STORE_CALC; nsTArray<nsStyleCoord>& coords = basicShape->Coordinates(); for (size_t j = 1; j <= 4; ++j) { const nsCSSValue& val = shapeFunction->Item(j); nsStyleCoord inset; // Fill missing values to get 4 at the end. if (val.GetUnit() == eCSSUnit_Null) { if (j == 4) { inset = coords[1]; } else { MOZ_ASSERT(j != 1, "first argument not specified"); inset = coords[0]; } } else { DebugOnly<bool> didSetInset = SetCoord(val, inset, nsStyleCoord(), mask, aStyleContext, aPresContext, aConditions); MOZ_ASSERT(didSetInset, "unexpected inset unit"); } coords.AppendElement(inset); } nsStyleCorners& insetRadius = basicShape->GetRadius(); if (shapeFunction->Item(5).GetUnit() == eCSSUnit_Array) { nsCSSValue::Array* radiiArray = shapeFunction->Item(5).GetArrayValue(); NS_FOR_CSS_FULL_CORNERS(corner) { int cx = NS_FULL_TO_HALF_CORNER(corner, false); int cy = NS_FULL_TO_HALF_CORNER(corner, true); const nsCSSValue& radius = radiiArray->Item(corner); nsStyleCoord coordX, coordY; DebugOnly<bool> didSetRadii = SetPairCoords(radius, coordX, coordY, nsStyleCoord(), nsStyleCoord(), mask, aStyleContext, aPresContext, aConditions); MOZ_ASSERT(didSetRadii, "unexpected radius unit"); insetRadius.Set(cx, coordX); insetRadius.Set(cy, coordY); } } else { MOZ_ASSERT(shapeFunction->Item(5).GetUnit() == eCSSUnit_Null, "unexpected value"); // Initialize border-radius nsStyleCoord zero; zero.SetCoordValue(0); NS_FOR_CSS_HALF_CORNERS(j) { insetRadius.Set(j, zero); } } } else { NS_NOTREACHED("unexpected basic shape function"); } return basicShape.forget(); } template<typename ReferenceBox> static void SetStyleShapeSourceToCSSValue( StyleShapeSource<ReferenceBox>* aShapeSource, const nsCSSValue* aValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { MOZ_ASSERT(aValue->GetUnit() == eCSSUnit_Array, "expected a basic shape or reference box"); const nsCSSValue::Array* array = aValue->GetArrayValue(); MOZ_ASSERT(array->Count() == 1 || array->Count() == 2, "Expect one or both of a shape function and a reference box"); ReferenceBox referenceBox = ReferenceBox::NoBox; RefPtr<StyleBasicShape> basicShape; for (size_t i = 0; i < array->Count(); ++i) { const nsCSSValue& item = array->Item(i); if (item.GetUnit() == eCSSUnit_Enumerated) { referenceBox = static_cast<ReferenceBox>(item.GetIntValue()); } else if (item.GetUnit() == eCSSUnit_Function) { basicShape = GetStyleBasicShapeFromCSSValue(item, aStyleContext, aPresContext, aConditions); } else { MOZ_ASSERT_UNREACHABLE("Unexpected unit!"); return; } } if (basicShape) { aShapeSource->SetBasicShape(basicShape, referenceBox); } else { aShapeSource->SetReferenceBox(referenceBox); } } // Returns true if the nsStyleFilter was successfully set using the nsCSSValue. static bool SetStyleFilterToCSSValue(nsStyleFilter* aStyleFilter, const nsCSSValue& aValue, nsStyleContext* aStyleContext, nsPresContext* aPresContext, RuleNodeCacheConditions& aConditions) { nsCSSUnit unit = aValue.GetUnit(); if (unit == eCSSUnit_URL) { return aStyleFilter->SetURL(aValue.GetURLStructValue()); } MOZ_ASSERT(unit == eCSSUnit_Function, "expected a filter function"); nsCSSValue::Array* filterFunction = aValue.GetArrayValue(); nsCSSKeyword functionName = (nsCSSKeyword)filterFunction->Item(0).GetIntValue(); int32_t type; DebugOnly<bool> foundKeyword = nsCSSProps::FindKeyword(functionName, nsCSSProps::kFilterFunctionKTable, type); MOZ_ASSERT(foundKeyword, "unknown filter type"); if (type == NS_STYLE_FILTER_DROP_SHADOW) { RefPtr<nsCSSShadowArray> shadowArray = GetShadowData( filterFunction->Item(1).GetListValue(), aStyleContext, false, aPresContext, aConditions); aStyleFilter->SetDropShadow(shadowArray); return true; } int32_t mask = SETCOORD_PERCENT | SETCOORD_FACTOR; if (type == NS_STYLE_FILTER_BLUR) { mask = SETCOORD_LENGTH | SETCOORD_CALC_LENGTH_ONLY | SETCOORD_CALC_CLAMP_NONNEGATIVE; } else if (type == NS_STYLE_FILTER_HUE_ROTATE) { mask = SETCOORD_ANGLE; } MOZ_ASSERT(filterFunction->Count() == 2, "all filter functions should have exactly one argument"); nsCSSValue& arg = filterFunction->Item(1); nsStyleCoord filterParameter; DebugOnly<bool> didSetCoord = SetCoord(arg, filterParameter, nsStyleCoord(), mask, aStyleContext, aPresContext, aConditions); aStyleFilter->SetFilterParameter(filterParameter, type); MOZ_ASSERT(didSetCoord, "unexpected unit"); return true; } const void* nsRuleNode::ComputeSVGResetData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(SVGReset, svgReset, parentSVGReset) // stop-color: const nsCSSValue* stopColorValue = aRuleData->ValueForStopColor(); if (eCSSUnit_Initial == stopColorValue->GetUnit() || eCSSUnit_Unset == stopColorValue->GetUnit()) { svgReset->mStopColor = NS_RGB(0, 0, 0); } else { SetColor(*stopColorValue, parentSVGReset->mStopColor, mPresContext, aContext, svgReset->mStopColor, conditions); } // flood-color: const nsCSSValue* floodColorValue = aRuleData->ValueForFloodColor(); if (eCSSUnit_Initial == floodColorValue->GetUnit() || eCSSUnit_Unset == floodColorValue->GetUnit()) { svgReset->mFloodColor = NS_RGB(0, 0, 0); } else { SetColor(*floodColorValue, parentSVGReset->mFloodColor, mPresContext, aContext, svgReset->mFloodColor, conditions); } // lighting-color: const nsCSSValue* lightingColorValue = aRuleData->ValueForLightingColor(); if (eCSSUnit_Initial == lightingColorValue->GetUnit() || eCSSUnit_Unset == lightingColorValue->GetUnit()) { svgReset->mLightingColor = NS_RGB(255, 255, 255); } else { SetColor(*lightingColorValue, parentSVGReset->mLightingColor, mPresContext, aContext, svgReset->mLightingColor, conditions); } // clip-path: url, <basic-shape> || <geometry-box>, none, inherit const nsCSSValue* clipPathValue = aRuleData->ValueForClipPath(); switch (clipPathValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_None: case eCSSUnit_Initial: case eCSSUnit_Unset: svgReset->mClipPath = StyleClipPath(); break; case eCSSUnit_Inherit: conditions.SetUncacheable(); svgReset->mClipPath = parentSVGReset->mClipPath; break; case eCSSUnit_URL: { svgReset->mClipPath = StyleClipPath(); svgReset->mClipPath.SetURL(clipPathValue->GetURLStructValue()); break; } case eCSSUnit_Array: { svgReset->mClipPath = StyleClipPath(); SetStyleShapeSourceToCSSValue(&svgReset->mClipPath, clipPathValue, aContext, mPresContext, conditions); break; } default: NS_NOTREACHED("unexpected unit"); } // stop-opacity: SetFactor(*aRuleData->ValueForStopOpacity(), svgReset->mStopOpacity, conditions, parentSVGReset->mStopOpacity, 1.0f, SETFCT_OPACITY | SETFCT_UNSET_INITIAL); // flood-opacity: SetFactor(*aRuleData->ValueForFloodOpacity(), svgReset->mFloodOpacity, conditions, parentSVGReset->mFloodOpacity, 1.0f, SETFCT_OPACITY | SETFCT_UNSET_INITIAL); // dominant-baseline: enum, inherit, initial SetValue(*aRuleData->ValueForDominantBaseline(), svgReset->mDominantBaseline, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentSVGReset->mDominantBaseline, NS_STYLE_DOMINANT_BASELINE_AUTO); // vector-effect: enum, inherit, initial SetValue(*aRuleData->ValueForVectorEffect(), svgReset->mVectorEffect, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentSVGReset->mVectorEffect, NS_STYLE_VECTOR_EFFECT_NONE); // mask-type: enum, inherit, initial SetValue(*aRuleData->ValueForMaskType(), svgReset->mMaskType, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentSVGReset->mMaskType, NS_STYLE_MASK_TYPE_LUMINANCE); uint32_t maxItemCount = 1; bool rebuild = false; // mask-image: none | <url> | <image-list> | <element-reference> | <gradient> nsStyleImage initialImage; SetImageLayerList(aContext, *aRuleData->ValueForMaskImage(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mImage, initialImage, parentSVGReset->mMask.mImageCount, svgReset->mMask.mImageCount, maxItemCount, rebuild, conditions); SetImageLayerList(aContext, *aRuleData->ValueForMaskImage(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mSourceURI, RefPtr<css::URLValueData>(), parentSVGReset->mMask.mImageCount, svgReset->mMask.mImageCount, maxItemCount, rebuild, conditions); // mask-repeat: enum, inherit, initial [pair list] nsStyleImageLayers::Repeat initialRepeat; initialRepeat.SetInitialValues(); SetImageLayerPairList(aContext, *aRuleData->ValueForMaskRepeat(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mRepeat, initialRepeat, parentSVGReset->mMask.mRepeatCount, svgReset->mMask.mRepeatCount, maxItemCount, rebuild, conditions); // mask-clip: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForMaskClip(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mClip, StyleGeometryBox::Border, parentSVGReset->mMask.mClipCount, svgReset->mMask.mClipCount, maxItemCount, rebuild, conditions); // mask-origin: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForMaskOrigin(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mOrigin, StyleGeometryBox::Border, parentSVGReset->mMask.mOriginCount, svgReset->mMask.mOriginCount, maxItemCount, rebuild, conditions); // mask-position-x/y: enum, length, percent (flags), inherit [list] Position::Coord initialPositionCoord; initialPositionCoord.mPercent = 0.0f; initialPositionCoord.mLength = 0; initialPositionCoord.mHasPercent = true; SetImageLayerPositionCoordList( aContext, *aRuleData->ValueForMaskPositionX(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &Position::mXPosition, initialPositionCoord, parentSVGReset->mMask.mPositionXCount, svgReset->mMask.mPositionXCount, maxItemCount, rebuild, conditions); SetImageLayerPositionCoordList( aContext, *aRuleData->ValueForMaskPositionY(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &Position::mYPosition, initialPositionCoord, parentSVGReset->mMask.mPositionYCount, svgReset->mMask.mPositionYCount, maxItemCount, rebuild, conditions); // mask-size: enum, length, auto, inherit, initial [pair list] nsStyleImageLayers::Size initialSize; initialSize.SetInitialValues(); SetImageLayerPairList(aContext, *aRuleData->ValueForMaskSize(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mSize, initialSize, parentSVGReset->mMask.mSizeCount, svgReset->mMask.mSizeCount, maxItemCount, rebuild, conditions); // mask-mode: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForMaskMode(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mMaskMode, uint8_t(NS_STYLE_MASK_MODE_MATCH_SOURCE), parentSVGReset->mMask.mMaskModeCount, svgReset->mMask.mMaskModeCount, maxItemCount, rebuild, conditions); // mask-composite: enum, inherit, initial [list] SetImageLayerList(aContext, *aRuleData->ValueForMaskComposite(), svgReset->mMask.mLayers, parentSVGReset->mMask.mLayers, &nsStyleImageLayers::Layer::mComposite, uint8_t(NS_STYLE_MASK_COMPOSITE_ADD), parentSVGReset->mMask.mCompositeCount, svgReset->mMask.mCompositeCount, maxItemCount, rebuild, conditions); if (rebuild) { FillAllBackgroundLists(svgReset->mMask, maxItemCount); } COMPUTE_END_RESET(SVGReset, svgReset) } const void* nsRuleNode::ComputeVariablesData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_INHERITED(Variables, variables, parentVariables) MOZ_ASSERT(aRuleData->mVariables, "shouldn't be in ComputeVariablesData if there were no variable " "declarations specified"); CSSVariableResolver resolver(&variables->mVariables); resolver.Resolve(&parentVariables->mVariables, aRuleData->mVariables); conditions.SetUncacheable(); COMPUTE_END_INHERITED(Variables, variables) } const void* nsRuleNode::ComputeEffectsData(void* aStartStruct, const nsRuleData* aRuleData, nsStyleContext* aContext, nsRuleNode* aHighestNode, const RuleDetail aRuleDetail, const RuleNodeCacheConditions aConditions) { COMPUTE_START_RESET(Effects, effects, parentEffects) // filter: url, none, inherit const nsCSSValue* filterValue = aRuleData->ValueForFilter(); switch (filterValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_None: case eCSSUnit_Initial: case eCSSUnit_Unset: effects->mFilters.Clear(); break; case eCSSUnit_Inherit: conditions.SetUncacheable(); effects->mFilters = parentEffects->mFilters; break; case eCSSUnit_List: case eCSSUnit_ListDep: { effects->mFilters.Clear(); const nsCSSValueList* cur = filterValue->GetListValue(); while (cur) { nsStyleFilter styleFilter; if (!SetStyleFilterToCSSValue(&styleFilter, cur->mValue, aContext, mPresContext, conditions)) { effects->mFilters.Clear(); break; } MOZ_ASSERT(styleFilter.GetType() != NS_STYLE_FILTER_NONE, "filter should be set"); effects->mFilters.AppendElement(styleFilter); cur = cur->mNext; } break; } default: NS_NOTREACHED("unexpected unit"); } // box-shadow: none, list, inherit, initial const nsCSSValue* boxShadowValue = aRuleData->ValueForBoxShadow(); switch (boxShadowValue->GetUnit()) { case eCSSUnit_Null: break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_None: effects->mBoxShadow = nullptr; break; case eCSSUnit_Inherit: effects->mBoxShadow = parentEffects->mBoxShadow; conditions.SetUncacheable(); break; case eCSSUnit_List: case eCSSUnit_ListDep: effects->mBoxShadow = GetShadowData(boxShadowValue->GetListValue(), aContext, true, mPresContext, conditions); break; default: MOZ_ASSERT(false, "unrecognized shadow unit"); } // clip property: length, auto, inherit const nsCSSValue* clipValue = aRuleData->ValueForClip(); switch (clipValue->GetUnit()) { case eCSSUnit_Inherit: conditions.SetUncacheable(); effects->mClipFlags = parentEffects->mClipFlags; effects->mClip = parentEffects->mClip; break; case eCSSUnit_Initial: case eCSSUnit_Unset: case eCSSUnit_Auto: effects->mClipFlags = NS_STYLE_CLIP_AUTO; effects->mClip.SetRect(0,0,0,0); break; case eCSSUnit_Null: break; case eCSSUnit_Rect: { const nsCSSRect& clipRect = clipValue->GetRectValue(); effects->mClipFlags = NS_STYLE_CLIP_RECT; if (clipRect.mTop.GetUnit() == eCSSUnit_Auto) { effects->mClip.y = 0; effects->mClipFlags |= NS_STYLE_CLIP_TOP_AUTO; } else if (clipRect.mTop.IsLengthUnit()) { effects->mClip.y = CalcLength(clipRect.mTop, aContext, mPresContext, conditions); } if (clipRect.mBottom.GetUnit() == eCSSUnit_Auto) { // Setting to NS_MAXSIZE for the 'auto' case ensures that // the clip rect is nonempty. It is important that mClip be // nonempty if the actual clip rect could be nonempty. effects->mClip.height = NS_MAXSIZE; effects->mClipFlags |= NS_STYLE_CLIP_BOTTOM_AUTO; } else if (clipRect.mBottom.IsLengthUnit()) { effects->mClip.height = CalcLength(clipRect.mBottom, aContext, mPresContext, conditions) - effects->mClip.y; } if (clipRect.mLeft.GetUnit() == eCSSUnit_Auto) { effects->mClip.x = 0; effects->mClipFlags |= NS_STYLE_CLIP_LEFT_AUTO; } else if (clipRect.mLeft.IsLengthUnit()) { effects->mClip.x = CalcLength(clipRect.mLeft, aContext, mPresContext, conditions); } if (clipRect.mRight.GetUnit() == eCSSUnit_Auto) { // Setting to NS_MAXSIZE for the 'auto' case ensures that // the clip rect is nonempty. It is important that mClip be // nonempty if the actual clip rect could be nonempty. effects->mClip.width = NS_MAXSIZE; effects->mClipFlags |= NS_STYLE_CLIP_RIGHT_AUTO; } else if (clipRect.mRight.IsLengthUnit()) { effects->mClip.width = CalcLength(clipRect.mRight, aContext, mPresContext, conditions) - effects->mClip.x; } break; } default: MOZ_ASSERT(false, "unrecognized clip unit"); } // opacity: factor, inherit, initial SetFactor(*aRuleData->ValueForOpacity(), effects->mOpacity, conditions, parentEffects->mOpacity, 1.0f, SETFCT_OPACITY | SETFCT_UNSET_INITIAL); // mix-blend-mode: enum, inherit, initial SetValue(*aRuleData->ValueForMixBlendMode(), effects->mMixBlendMode, conditions, SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL, parentEffects->mMixBlendMode, NS_STYLE_BLEND_NORMAL); COMPUTE_END_RESET(Effects, effects) } const void* nsRuleNode::GetStyleData(nsStyleStructID aSID, nsStyleContext* aContext, bool aComputeData) { NS_ASSERTION(IsUsedDirectly(), "if we ever call this on rule nodes that aren't used " "directly, we should adjust handling of mDependentBits " "in some way."); MOZ_ASSERT(!aContext->GetCachedStyleData(aSID), "style context should not have cached data for struct"); const void *data; // Never use cached data for animated style inside a pseudo-element; // see comment on cacheability in AnimValuesStyleRule::MapRuleInfoInto. if (!(HasAnimationData() && ParentHasPseudoElementData(aContext))) { data = mStyleData.GetStyleData(aSID, aContext, aComputeData); if (MOZ_LIKELY(data != nullptr)) { // For inherited structs, mark the struct (which will be set on // the context by our caller) as not being owned by the context. if (!nsCachedStyleData::IsReset(aSID)) { aContext->AddStyleBit(nsCachedStyleData::GetBitForSID(aSID)); } else if (HasAnimationData()) { // If we have animation data, the struct should be cached on the style // context so that we can peek the struct. // See comment in AnimValuesStyleRule::MapRuleInfoInto. StoreStyleOnContext(aContext, aSID, const_cast<void*>(data)); } return data; // We have a fully specified struct. Just return it. } } if (MOZ_UNLIKELY(!aComputeData)) return nullptr; // Nothing is cached. We'll have to delve further and examine our rules. data = WalkRuleTree(aSID, aContext); MOZ_ASSERT(data, "should have aborted on out-of-memory"); return data; } void nsRuleNode::GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty, nsCSSValue* aValue) { for (nsRuleNode* node = this; node; node = node->GetParent()) { nsIStyleRule* rule = node->GetRule(); if (!rule) { continue; } if (rule->GetDiscretelyAnimatedCSSValue(aProperty, aValue)) { return; } } } /* static */ bool nsRuleNode::HasAuthorSpecifiedRules(nsStyleContext* aStyleContext, uint32_t ruleTypeMask, bool aAuthorColorsAllowed) { #ifdef MOZ_STYLO if (aStyleContext->StyleSource().IsServoComputedValues()) { NS_WARNING("stylo: nsRuleNode::HasAuthorSpecifiedRules not implemented"); return true; } #endif uint32_t inheritBits = 0; if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) inheritBits |= NS_STYLE_INHERIT_BIT(Background); if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER) inheritBits |= NS_STYLE_INHERIT_BIT(Border); if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) inheritBits |= NS_STYLE_INHERIT_BIT(Padding); if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) inheritBits |= NS_STYLE_INHERIT_BIT(Text); // properties in the SIDS, whether or not we care about them size_t nprops = 0, backgroundOffset, borderOffset, paddingOffset, textShadowOffset; // We put the reset properties the start of the nsCSSValue array.... if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) { backgroundOffset = nprops; nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Background); } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER) { borderOffset = nprops; nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Border); } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) { paddingOffset = nprops; nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Padding); } // ...and the inherited properties at the end of the array. size_t inheritedOffset = nprops; if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) { textShadowOffset = nprops; nprops += nsCSSProps::PropertyCountInStruct(eStyleStruct_Text); } void* dataStorage = alloca(nprops * sizeof(nsCSSValue)); AutoCSSValueArray dataArray(dataStorage, nprops); /* We're relying on the use of |aStyleContext| not mutating it! */ nsRuleData ruleData(inheritBits, dataArray.get(), aStyleContext->PresContext(), aStyleContext); if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) { ruleData.mValueOffsets[eStyleStruct_Background] = backgroundOffset; } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER) { ruleData.mValueOffsets[eStyleStruct_Border] = borderOffset; } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) { ruleData.mValueOffsets[eStyleStruct_Padding] = paddingOffset; } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) { ruleData.mValueOffsets[eStyleStruct_Text] = textShadowOffset; } static const nsCSSPropertyID backgroundValues[] = { eCSSProperty_background_color, eCSSProperty_background_image, }; static const nsCSSPropertyID borderValues[] = { eCSSProperty_border_top_color, eCSSProperty_border_top_style, eCSSProperty_border_top_width, eCSSProperty_border_right_color, eCSSProperty_border_right_style, eCSSProperty_border_right_width, eCSSProperty_border_bottom_color, eCSSProperty_border_bottom_style, eCSSProperty_border_bottom_width, eCSSProperty_border_left_color, eCSSProperty_border_left_style, eCSSProperty_border_left_width, eCSSProperty_border_top_left_radius, eCSSProperty_border_top_right_radius, eCSSProperty_border_bottom_right_radius, eCSSProperty_border_bottom_left_radius, }; static const nsCSSPropertyID paddingValues[] = { eCSSProperty_padding_top, eCSSProperty_padding_right, eCSSProperty_padding_bottom, eCSSProperty_padding_left, }; static const nsCSSPropertyID textShadowValues[] = { eCSSProperty_text_shadow }; // Number of properties we care about size_t nValues = 0; nsCSSValue* values[MOZ_ARRAY_LENGTH(backgroundValues) + MOZ_ARRAY_LENGTH(borderValues) + MOZ_ARRAY_LENGTH(paddingValues) + MOZ_ARRAY_LENGTH(textShadowValues)]; nsCSSPropertyID properties[MOZ_ARRAY_LENGTH(backgroundValues) + MOZ_ARRAY_LENGTH(borderValues) + MOZ_ARRAY_LENGTH(paddingValues) + MOZ_ARRAY_LENGTH(textShadowValues)]; if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) { for (uint32_t i = 0, i_end = ArrayLength(backgroundValues); i < i_end; ++i) { properties[nValues] = backgroundValues[i]; values[nValues++] = ruleData.ValueFor(backgroundValues[i]); } } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BORDER) { for (uint32_t i = 0, i_end = ArrayLength(borderValues); i < i_end; ++i) { properties[nValues] = borderValues[i]; values[nValues++] = ruleData.ValueFor(borderValues[i]); } } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) { for (uint32_t i = 0, i_end = ArrayLength(paddingValues); i < i_end; ++i) { properties[nValues] = paddingValues[i]; values[nValues++] = ruleData.ValueFor(paddingValues[i]); } } if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) { for (uint32_t i = 0, i_end = ArrayLength(textShadowValues); i < i_end; ++i) { properties[nValues] = textShadowValues[i]; values[nValues++] = ruleData.ValueFor(textShadowValues[i]); } } nsStyleContext* styleContext = aStyleContext; // We need to be careful not to count styles covered up by user-important or // UA-important declarations. But we do want to catch explicit inherit // styling in those and check our parent style context to see whether we have // user styling for those properties. Note that we don't care here about // inheritance due to lack of a specified value, since all the properties we // care about are reset properties. bool haveExplicitUAInherit; do { haveExplicitUAInherit = false; for (nsRuleNode* ruleNode = styleContext->RuleNode(); ruleNode; ruleNode = ruleNode->GetParent()) { nsIStyleRule *rule = ruleNode->GetRule(); if (rule) { ruleData.mLevel = ruleNode->GetLevel(); ruleData.mIsImportantRule = ruleNode->IsImportantRule(); rule->MapRuleInfoInto(&ruleData); if (ruleData.mLevel == SheetType::Agent || ruleData.mLevel == SheetType::User) { // This is a rule whose effect we want to ignore, so if any of // the properties we care about were set, set them to the dummy // value that they'll never otherwise get. for (uint32_t i = 0; i < nValues; ++i) { nsCSSUnit unit = values[i]->GetUnit(); if (unit != eCSSUnit_Null && unit != eCSSUnit_Dummy && unit != eCSSUnit_DummyInherit) { if (unit == eCSSUnit_Inherit || (i >= inheritedOffset && unit == eCSSUnit_Unset)) { haveExplicitUAInherit = true; values[i]->SetDummyInheritValue(); } else { values[i]->SetDummyValue(); } } } } else { // If any of the values we care about was set by the above rule, // we have author style. for (uint32_t i = 0; i < nValues; ++i) { if (values[i]->GetUnit() != eCSSUnit_Null && values[i]->GetUnit() != eCSSUnit_Dummy && // see above values[i]->GetUnit() != eCSSUnit_DummyInherit) { // If author colors are not allowed, only claim to have // author-specified rules if we're looking at a non-color // property or if we're looking at the background color and it's // set to transparent. Anything else should get set to a dummy // value instead. if (aAuthorColorsAllowed || !nsCSSProps::PropHasFlags(properties[i], CSS_PROPERTY_IGNORED_WHEN_COLORS_DISABLED) || (properties[i] == eCSSProperty_background_color && !values[i]->IsNonTransparentColor())) { return true; } values[i]->SetDummyValue(); } } } } } if (haveExplicitUAInherit) { // reset all the eCSSUnit_Null values to eCSSUnit_Dummy (since they're // not styled by the author, or by anyone else), and then reset all the // eCSSUnit_DummyInherit values to eCSSUnit_Null (so we will be able to // detect them being styled by the author) and move up to our parent // style context. for (uint32_t i = 0; i < nValues; ++i) if (values[i]->GetUnit() == eCSSUnit_Null) values[i]->SetDummyValue(); for (uint32_t i = 0; i < nValues; ++i) if (values[i]->GetUnit() == eCSSUnit_DummyInherit) values[i]->Reset(); styleContext = styleContext->GetParent(); } } while (haveExplicitUAInherit && styleContext); return false; } /* static */ void nsRuleNode::ComputePropertiesOverridingAnimation( const nsTArray<nsCSSPropertyID>& aProperties, nsStyleContext* aStyleContext, nsCSSPropertyIDSet& aPropertiesOverridden) { /* * Set up an nsRuleData with all the structs needed for all of the * properties in aProperties. */ uint32_t structBits = 0; size_t nprops = 0; size_t offsets[nsStyleStructID_Length]; for (size_t propIdx = 0, propEnd = aProperties.Length(); propIdx < propEnd; ++propIdx) { nsCSSPropertyID prop = aProperties[propIdx]; nsStyleStructID sid = nsCSSProps::kSIDTable[prop]; uint32_t bit = nsCachedStyleData::GetBitForSID(sid); if (!(structBits & bit)) { structBits |= bit; offsets[sid] = nprops; nprops += nsCSSProps::PropertyCountInStruct(sid); } } void* dataStorage = alloca(nprops * sizeof(nsCSSValue)); AutoCSSValueArray dataArray(dataStorage, nprops); // We're relying on the use of |aStyleContext| not mutating it! nsRuleData ruleData(structBits, dataArray.get(), aStyleContext->PresContext(), aStyleContext); for (nsStyleStructID sid = nsStyleStructID(0); sid < nsStyleStructID_Length; sid = nsStyleStructID(sid + 1)) { if (structBits & nsCachedStyleData::GetBitForSID(sid)) { ruleData.mValueOffsets[sid] = offsets[sid]; } } /* * Actually walk up the rule tree until we're someplace less * specific than animations. */ for (nsRuleNode* ruleNode = aStyleContext->RuleNode(); ruleNode; ruleNode = ruleNode->GetParent()) { nsIStyleRule *rule = ruleNode->GetRule(); if (rule) { ruleData.mLevel = ruleNode->GetLevel(); ruleData.mIsImportantRule = ruleNode->IsImportantRule(); // Transitions are the only non-!important level overriding // animations in the cascade ordering. They also don't actually // override animations, since transitions are suppressed when both // are present. And since we might not have called // UpdateCascadeResults (which updates when they are suppressed // due to the presence of animations for the same element and // property) for transitions yet (which will make their // MapRuleInfoInto skip the properties that are currently // animating), we should skip them explicitly. if (ruleData.mLevel == SheetType::Transition) { continue; } if (!ruleData.mIsImportantRule) { // We're now equal to or less than the animation level; stop. break; } rule->MapRuleInfoInto(&ruleData); } } /* * Fill in which properties were overridden. */ for (size_t propIdx = 0, propEnd = aProperties.Length(); propIdx < propEnd; ++propIdx) { nsCSSPropertyID prop = aProperties[propIdx]; if (ruleData.ValueFor(prop)->GetUnit() != eCSSUnit_Null) { aPropertiesOverridden.AddProperty(prop); } } } /* static */ bool nsRuleNode::ComputeColor(const nsCSSValue& aValue, nsPresContext* aPresContext, nsStyleContext* aStyleContext, nscolor& aResult) { MOZ_ASSERT(aValue.GetUnit() != eCSSUnit_Inherit, "aValue shouldn't have eCSSUnit_Inherit"); MOZ_ASSERT(aValue.GetUnit() != eCSSUnit_Initial, "aValue shouldn't have eCSSUnit_Initial"); MOZ_ASSERT(aValue.GetUnit() != eCSSUnit_Unset, "aValue shouldn't have eCSSUnit_Unset"); RuleNodeCacheConditions conditions; bool ok = SetColor(aValue, NS_RGB(0, 0, 0), aPresContext, aStyleContext, aResult, conditions); MOZ_ASSERT(ok || !(aPresContext && aStyleContext)); return ok; } /* static */ bool nsRuleNode::ParentHasPseudoElementData(nsStyleContext* aContext) { nsStyleContext* parent = aContext->GetParent(); return parent && parent->HasPseudoElementData(); } /* static */ void nsRuleNode::StoreStyleOnContext(nsStyleContext* aContext, nsStyleStructID aSID, void* aStruct) { aContext->AddStyleBit(nsCachedStyleData::GetBitForSID(aSID)); aContext->SetStyle(aSID, aStruct); } #ifdef DEBUG bool nsRuleNode::ContextHasCachedData(nsStyleContext* aContext, nsStyleStructID aSID) { return !!aContext->GetCachedStyleData(aSID); } #endif