/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is mozilla.org code. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. * * Contributor(s): * David Hyatt * Pierre Phaneuf * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* the interface (to internal code) for retrieving computed style data */ #include "nsStyleConsts.h" #include "nsString.h" #include "nsPresContext.h" #include "nsIStyleRule.h" #include "nsCOMPtr.h" #include "nsStyleSet.h" #include "nsIPresShell.h" #include "nsRuleNode.h" #include "nsStyleContext.h" #include "prlog.h" #include "nsStyleAnimation.h" #ifdef DEBUG // #define NOISY_DEBUG #endif //---------------------------------------------------------------------- nsStyleContext::nsStyleContext(nsStyleContext* aParent, nsIAtom* aPseudoTag, nsCSSPseudoElements::Type aPseudoType, nsRuleNode* aRuleNode, nsPresContext* aPresContext) : mParent(aParent), mChild(nsnull), mEmptyChild(nsnull), mPseudoTag(aPseudoTag), mRuleNode(aRuleNode), mCachedResetData(nsnull), mBits(((PRUint32)aPseudoType) << NS_STYLE_CONTEXT_TYPE_SHIFT), mRefCnt(0) { PR_STATIC_ASSERT((PR_UINT32_MAX >> NS_STYLE_CONTEXT_TYPE_SHIFT) > nsCSSPseudoElements::ePseudo_MAX); mNextSibling = this; mPrevSibling = this; if (mParent) { mParent->AddRef(); mParent->AddChild(this); #ifdef DEBUG nsRuleNode *r1 = mParent->GetRuleNode(), *r2 = aRuleNode; while (r1->GetParent()) r1 = r1->GetParent(); while (r2->GetParent()) r2 = r2->GetParent(); NS_ASSERTION(r1 == r2, "must be in the same rule tree as parent"); #endif } ApplyStyleFixups(aPresContext); #define eStyleStruct_LastItem (nsStyleStructID_Length - 1) NS_ASSERTION(NS_STYLE_INHERIT_MASK & NS_STYLE_INHERIT_BIT(LastItem), "NS_STYLE_INHERIT_MASK must be bigger, and other bits shifted"); #undef eStyleStruct_LastItem mRuleNode->AddRef(); } nsStyleContext::~nsStyleContext() { NS_ASSERTION((nsnull == mChild) && (nsnull == mEmptyChild), "destructing context with children"); nsPresContext *presContext = mRuleNode->GetPresContext(); mRuleNode->Release(); presContext->PresShell()->StyleSet()-> NotifyStyleContextDestroyed(presContext, this); if (mParent) { mParent->RemoveChild(this); mParent->Release(); } // Free up our data structs. mCachedInheritedData.DestroyStructs(mBits, presContext); if (mCachedResetData) { mCachedResetData->Destroy(mBits, presContext); } } void nsStyleContext::AddChild(nsStyleContext* aChild) { NS_ASSERTION(aChild->mPrevSibling == aChild && aChild->mNextSibling == aChild, "child already in a child list"); nsStyleContext **list = aChild->mRuleNode->IsRoot() ? &mEmptyChild : &mChild; // Insert at the beginning of the list. See also FindChildWithRules. if (*list) { // Link into existing elements, if there are any. aChild->mNextSibling = (*list); aChild->mPrevSibling = (*list)->mPrevSibling; (*list)->mPrevSibling->mNextSibling = aChild; (*list)->mPrevSibling = aChild; } (*list) = aChild; } void nsStyleContext::RemoveChild(nsStyleContext* aChild) { NS_PRECONDITION(nsnull != aChild && this == aChild->mParent, "bad argument"); nsStyleContext **list = aChild->mRuleNode->IsRoot() ? &mEmptyChild : &mChild; if (aChild->mPrevSibling != aChild) { // has siblings if ((*list) == aChild) { (*list) = (*list)->mNextSibling; } } else { NS_ASSERTION((*list) == aChild, "bad sibling pointers"); (*list) = nsnull; } aChild->mPrevSibling->mNextSibling = aChild->mNextSibling; aChild->mNextSibling->mPrevSibling = aChild->mPrevSibling; aChild->mNextSibling = aChild; aChild->mPrevSibling = aChild; } already_AddRefed nsStyleContext::FindChildWithRules(const nsIAtom* aPseudoTag, nsRuleNode* aRuleNode, nsRuleNode* aRulesIfVisited, PRBool aRelevantLinkVisited) { NS_ABORT_IF_FALSE(aRulesIfVisited || !aRelevantLinkVisited, "aRelevantLinkVisited should only be set when we have a separate style"); PRUint32 threshold = 10; // The # of siblings we're willing to examine // before just giving this whole thing up. nsStyleContext* result = nsnull; nsStyleContext *list = aRuleNode->IsRoot() ? mEmptyChild : mChild; if (list) { nsStyleContext *child = list; do { if (child->mRuleNode == aRuleNode && child->mPseudoTag == aPseudoTag && !child->IsStyleIfVisited() && child->RelevantLinkVisited() == aRelevantLinkVisited) { PRBool match = PR_FALSE; if (aRulesIfVisited) { match = child->GetStyleIfVisited() && child->GetStyleIfVisited()->mRuleNode == aRulesIfVisited; } else { match = !child->GetStyleIfVisited(); } if (match) { result = child; break; } } child = child->mNextSibling; threshold--; if (threshold == 0) break; } while (child != list); } if (result) { if (result != list) { // Move result to the front of the list. RemoveChild(result); AddChild(result); } // Add reference for the caller. result->AddRef(); } return result; } const void* nsStyleContext::GetCachedStyleData(nsStyleStructID aSID) { const void* cachedData; PRBool isReset = nsCachedStyleData::IsReset(aSID); if (isReset) { if (mCachedResetData) { char* slot = reinterpret_cast(mCachedResetData) + nsCachedStyleData::gInfo[aSID].mInheritResetOffset; cachedData = *reinterpret_cast(slot); } else { cachedData = nsnull; } } else { char* slot = reinterpret_cast(&mCachedInheritedData) + nsCachedStyleData::gInfo[aSID].mInheritResetOffset; cachedData = *reinterpret_cast(slot); } return cachedData; } const void* nsStyleContext::GetStyleData(nsStyleStructID aSID) { const void* cachedData = GetCachedStyleData(aSID); if (cachedData) return cachedData; // We have computed data stored on this node in the context tree. return mRuleNode->GetStyleData(aSID, this, PR_TRUE); // Our rule node will take care of it for us. } // This is an evil evil function, since it forces you to alloc your own separate copy of // style data! Do not use this function unless you absolutely have to! You should avoid // this at all costs! -dwh void* nsStyleContext::GetUniqueStyleData(const nsStyleStructID& aSID) { // If we already own the struct and no kids could depend on it, then // just return it. (We leak in this case if there are kids -- and this // function really shouldn't be called for style contexts that could // have kids depending on the data. ClearStyleData would be OK, but // this test for no mChild or mEmptyChild doesn't catch that case.) const void *current = GetStyleData(aSID); if (!mChild && !mEmptyChild && !(mBits & nsCachedStyleData::GetBitForSID(aSID)) && GetCachedStyleData(aSID)) return const_cast(current); void* result; nsPresContext *presContext = PresContext(); switch (aSID) { #define UNIQUE_CASE(c_) \ case eStyleStruct_##c_: \ result = new (presContext) nsStyle##c_( \ * static_cast(current)); \ break; UNIQUE_CASE(Display) UNIQUE_CASE(Background) UNIQUE_CASE(Text) UNIQUE_CASE(TextReset) #undef UNIQUE_CASE default: NS_ERROR("Struct type not supported. Please find another way to do this if you can!\n"); return nsnull; } if (!result) { NS_WARNING("Ran out of memory while trying to allocate memory for a unique style struct! " "Returning the non-unique data."); return const_cast(current); } SetStyle(aSID, result); mBits &= ~nsCachedStyleData::GetBitForSID(aSID); return result; } void nsStyleContext::SetStyle(nsStyleStructID aSID, void* aStruct) { // This method should only be called from nsRuleNode! It is not a public // method! NS_ASSERTION(aSID >= 0 && aSID < nsStyleStructID_Length, "out of bounds"); // NOTE: nsCachedStyleData::GetStyleData works roughly the same way. // See the comments there (in nsRuleNode.h) for more details about // what this is doing and why. char* dataSlot; if (nsCachedStyleData::IsReset(aSID)) { if (!mCachedResetData) { mCachedResetData = new (mRuleNode->GetPresContext()) nsResetStyleData; // XXXbz And if that fails? } dataSlot = reinterpret_cast(mCachedResetData) + nsCachedStyleData::gInfo[aSID].mInheritResetOffset; } else { dataSlot = reinterpret_cast(&mCachedInheritedData) + nsCachedStyleData::gInfo[aSID].mInheritResetOffset; } NS_ASSERTION(!*reinterpret_cast(dataSlot) || (mBits & nsCachedStyleData::GetBitForSID(aSID)), "Going to leak style data"); *reinterpret_cast(dataSlot) = aStruct; } void nsStyleContext::ApplyStyleFixups(nsPresContext* aPresContext) { // See if we have any text decorations. // First see if our parent has text decorations. If our parent does, then we inherit the bit. if (mParent && mParent->HasTextDecorations()) mBits |= NS_STYLE_HAS_TEXT_DECORATIONS; else { // We might have defined a decoration. const nsStyleTextReset* text = GetStyleTextReset(); if (text->mTextDecoration != NS_STYLE_TEXT_DECORATION_NONE && text->mTextDecoration != NS_STYLE_TEXT_DECORATION_OVERRIDE_ALL) mBits |= NS_STYLE_HAS_TEXT_DECORATIONS; } if ((mParent && mParent->HasPseudoElementData()) || mPseudoTag) { mBits |= NS_STYLE_HAS_PSEUDO_ELEMENT_DATA; } // Correct tables. const nsStyleDisplay* disp = GetStyleDisplay(); if (disp->mDisplay == NS_STYLE_DISPLAY_TABLE) { // -moz-center and -moz-right are used for HTML's alignment // This is covering the
...
case. // In this case, we don't want to inherit the text alignment into the table. const nsStyleText* text = GetStyleText(); if (text->mTextAlign == NS_STYLE_TEXT_ALIGN_MOZ_CENTER || text->mTextAlign == NS_STYLE_TEXT_ALIGN_MOZ_RIGHT) { nsStyleText* uniqueText = (nsStyleText*)GetUniqueStyleData(eStyleStruct_Text); uniqueText->mTextAlign = NS_STYLE_TEXT_ALIGN_DEFAULT; } } // CSS2.1 section 9.2.4 specifies fixups for the 'display' property of // the root element. We can't implement them in nsRuleNode because we // don't want to store all display structs that aren't 'block', // 'inline', or 'table' in the style context tree on the off chance // that the root element has its style reresolved later. So do them // here if needed, by changing the style data, so that other code // doesn't get confused by looking at the style data. if (!mParent) { if (disp->mDisplay != NS_STYLE_DISPLAY_NONE && disp->mDisplay != NS_STYLE_DISPLAY_BLOCK && disp->mDisplay != NS_STYLE_DISPLAY_TABLE) { nsStyleDisplay *mutable_display = static_cast (GetUniqueStyleData(eStyleStruct_Display)); if (mutable_display->mDisplay == NS_STYLE_DISPLAY_INLINE_TABLE) mutable_display->mDisplay = NS_STYLE_DISPLAY_TABLE; else mutable_display->mDisplay = NS_STYLE_DISPLAY_BLOCK; } } // Computer User Interface style, to trigger loads of cursors GetStyleUserInterface(); } nsChangeHint nsStyleContext::CalcStyleDifference(nsStyleContext* aOther) { nsChangeHint hint = NS_STYLE_HINT_NONE; NS_ENSURE_TRUE(aOther, hint); // We must always ensure that we populate the structs on the new style // context that are filled in on the old context, so that if we get // two style changes in succession, the second of which causes a real // style change, the PeekStyleData doesn't return null (implying that // nobody ever looked at that struct's data). In other words, we // can't skip later structs if we get a big change up front, because // we could later get a small change in one of those structs that we // don't want to miss. // If our rule nodes are the same, then we are looking at the same // style data. We know this because CalcStyleDifference is always // called on two style contexts that point to the same element, so we // know that our position in the style context tree is the same and // our position in the rule node tree is also the same. PRBool compare = mRuleNode != aOther->mRuleNode; nsChangeHint maxHint = nsChangeHint(NS_STYLE_HINT_FRAMECHANGE | nsChangeHint_UpdateCursor); #define DO_STRUCT_DIFFERENCE(struct_) \ PR_BEGIN_MACRO \ NS_ASSERTION(NS_IsHintSubset(nsStyle##struct_::MaxDifference(), maxHint), \ "Struct placed in the wrong maxHint section"); \ const nsStyle##struct_* this##struct_ = PeekStyle##struct_(); \ if (this##struct_) { \ const nsStyle##struct_* other##struct_ = aOther->GetStyle##struct_(); \ if ((compare || nsStyle##struct_::ForceCompare()) && \ !NS_IsHintSubset(maxHint, hint) && \ this##struct_ != other##struct_) { \ NS_ASSERTION(NS_IsHintSubset( \ this##struct_->CalcDifference(*other##struct_), \ nsStyle##struct_::MaxDifference()), \ "CalcDifference() returned bigger hint than MaxDifference()"); \ NS_UpdateHint(hint, this##struct_->CalcDifference(*other##struct_)); \ } \ } \ PR_END_MACRO // We begin by examining those style structs that are capable of // causing the maximal difference, a FRAMECHANGE. // FRAMECHANGE Structs: Display, XUL, Content, UserInterface, // Visibility, Outline, TableBorder, Table, Text, UIReset, Quotes DO_STRUCT_DIFFERENCE(Display); DO_STRUCT_DIFFERENCE(XUL); DO_STRUCT_DIFFERENCE(Column); DO_STRUCT_DIFFERENCE(Content); DO_STRUCT_DIFFERENCE(UserInterface); DO_STRUCT_DIFFERENCE(Visibility); DO_STRUCT_DIFFERENCE(Outline); DO_STRUCT_DIFFERENCE(TableBorder); DO_STRUCT_DIFFERENCE(Table); DO_STRUCT_DIFFERENCE(UIReset); DO_STRUCT_DIFFERENCE(Text); DO_STRUCT_DIFFERENCE(List); // If the quotes implementation is ever going to change we might not need // a framechange here and a reflow should be sufficient. See bug 35768. DO_STRUCT_DIFFERENCE(Quotes); maxHint = nsChangeHint(NS_STYLE_HINT_REFLOW | nsChangeHint_UpdateEffects); DO_STRUCT_DIFFERENCE(SVGReset); DO_STRUCT_DIFFERENCE(SVG); // At this point, we know that the worst kind of damage we could do is // a reflow. maxHint = NS_STYLE_HINT_REFLOW; // The following structs cause (as their maximal difference) a reflow // to occur. REFLOW Structs: Font, Margin, Padding, Border, List, // Position, Text, TextReset DO_STRUCT_DIFFERENCE(Font); DO_STRUCT_DIFFERENCE(Margin); DO_STRUCT_DIFFERENCE(Padding); DO_STRUCT_DIFFERENCE(Border); DO_STRUCT_DIFFERENCE(Position); DO_STRUCT_DIFFERENCE(TextReset); // At this point, we know that the worst kind of damage we could do is // a re-render (i.e., a VISUAL change). maxHint = NS_STYLE_HINT_VISUAL; // The following structs cause (as their maximal difference) a // re-render to occur. VISUAL Structs: Color, Background DO_STRUCT_DIFFERENCE(Color); DO_STRUCT_DIFFERENCE(Background); #undef DO_STRUCT_DIFFERENCE // Note that we do not check whether this->RelevantLinkVisited() != // aOther->RelevantLinkVisited(); we don't need to since // nsCSSFrameConstructor::DoContentStateChanged always adds // nsChangeHint_RepaintFrame for NS_EVENT_STATE_VISITED changes (and // needs to, since HasStateDependentStyle probably doesn't work right // for NS_EVENT_STATE_VISITED). Hopefully this doesn't actually // expose whether links are visited to performance tests since all // link coloring happens asynchronously at a time when it's hard for // the page to measure. // However, we do need to compute the larger of the changes that can // happen depending on whether the link is visited or unvisited, since // doing only the one that's currently appropriate would expose which // links are in history to easy performance measurement. Therefore, // here, we add nsChangeHint_RepaintFrame hints (the maximum for // things that can depend on :visited) for the properties on which we // call GetVisitedDependentColor. nsStyleContext *thisVis = GetStyleIfVisited(), *otherVis = aOther->GetStyleIfVisited(); if (!thisVis != !otherVis) { // One style context has a style-if-visited and the other doesn't. // Presume a difference. NS_UpdateHint(hint, nsChangeHint_RepaintFrame); } else if (thisVis && !NS_IsHintSubset(nsChangeHint_RepaintFrame, hint)) { // Both style contexts have a style-if-visited. PRBool change = PR_FALSE; // NB: Calling Peek on |this|, not |thisVis|, since callers may look // at a struct on |this| without looking at the same struct on // |thisVis| (including this function if we skip one of these checks // due to change being true already or due to the old style context // not having a style-if-visited), but not the other way around. if (PeekStyleColor()) { if (thisVis->GetStyleColor()->mColor != otherVis->GetStyleColor()->mColor) { change = PR_TRUE; } } // NB: Calling Peek on |this|, not |thisVis| (see above). if (!change && PeekStyleBackground()) { if (thisVis->GetStyleBackground()->mBackgroundColor != otherVis->GetStyleBackground()->mBackgroundColor) { change = PR_TRUE; } } // NB: Calling Peek on |this|, not |thisVis| (see above). if (!change && PeekStyleBorder()) { const nsStyleBorder *thisVisBorder = thisVis->GetStyleBorder(); const nsStyleBorder *otherVisBorder = otherVis->GetStyleBorder(); NS_FOR_CSS_SIDES(side) { PRBool thisFG, otherFG; nscolor thisColor, otherColor; thisVisBorder->GetBorderColor(side, thisColor, thisFG); otherVisBorder->GetBorderColor(side, otherColor, otherFG); if (thisFG != otherFG || (!thisFG && thisColor != otherColor)) { change = PR_TRUE; break; } } } // NB: Calling Peek on |this|, not |thisVis| (see above). if (!change && PeekStyleOutline()) { const nsStyleOutline *thisVisOutline = thisVis->GetStyleOutline(); const nsStyleOutline *otherVisOutline = otherVis->GetStyleOutline(); PRBool haveColor; nscolor thisColor, otherColor; if (thisVisOutline->GetOutlineInitialColor() != otherVisOutline->GetOutlineInitialColor() || (haveColor = thisVisOutline->GetOutlineColor(thisColor)) != otherVisOutline->GetOutlineColor(otherColor) || (haveColor && thisColor != otherColor)) { change = PR_TRUE; } } // NB: Calling Peek on |this|, not |thisVis| (see above). if (!change && PeekStyleColumn()) { const nsStyleColumn *thisVisColumn = thisVis->GetStyleColumn(); const nsStyleColumn *otherVisColumn = otherVis->GetStyleColumn(); if (thisVisColumn->mColumnRuleColor != otherVisColumn->mColumnRuleColor || thisVisColumn->mColumnRuleColorIsForeground != otherVisColumn->mColumnRuleColorIsForeground) { change = PR_TRUE; } } // NB: Calling Peek on |this|, not |thisVis| (see above). if (!change && PeekStyleSVG()) { const nsStyleSVG *thisVisSVG = thisVis->GetStyleSVG(); const nsStyleSVG *otherVisSVG = otherVis->GetStyleSVG(); if (thisVisSVG->mFill != otherVisSVG->mFill || thisVisSVG->mStroke != otherVisSVG->mStroke) { change = PR_TRUE; } } if (change) { NS_UpdateHint(hint, nsChangeHint_RepaintFrame); } } return hint; } void nsStyleContext::Mark() { // Mark our rule node. mRuleNode->Mark(); // Mark our children (i.e., tell them to mark their rule nodes, etc.). if (mChild) { nsStyleContext* child = mChild; do { child->Mark(); child = child->mNextSibling; } while (mChild != child); } if (mEmptyChild) { nsStyleContext* child = mEmptyChild; do { child->Mark(); child = child->mNextSibling; } while (mEmptyChild != child); } } #ifdef DEBUG void nsStyleContext::List(FILE* out, PRInt32 aIndent) { // Indent PRInt32 ix; for (ix = aIndent; --ix >= 0; ) fputs(" ", out); fprintf(out, "%p(%d) parent=%p ", (void*)this, mRefCnt, (void *)mParent); if (mPseudoTag) { nsAutoString buffer; mPseudoTag->ToString(buffer); fputs(NS_LossyConvertUTF16toASCII(buffer).get(), out); fputs(" ", out); } if (mRuleNode) { fputs("{\n", out); nsRuleNode* ruleNode = mRuleNode; while (ruleNode) { nsIStyleRule *styleRule = ruleNode->GetRule(); if (styleRule) { styleRule->List(out, aIndent + 1); } ruleNode = ruleNode->GetParent(); } for (ix = aIndent; --ix >= 0; ) fputs(" ", out); fputs("}\n", out); } else { fputs("{}\n", out); } if (nsnull != mChild) { nsStyleContext* child = mChild; do { child->List(out, aIndent + 1); child = child->mNextSibling; } while (mChild != child); } if (nsnull != mEmptyChild) { nsStyleContext* child = mEmptyChild; do { child->List(out, aIndent + 1); child = child->mNextSibling; } while (mEmptyChild != child); } } #endif // Overloaded new operator. Initializes the memory to 0 and relies on an arena // (which comes from the presShell) to perform the allocation. void* nsStyleContext::operator new(size_t sz, nsPresContext* aPresContext) CPP_THROW_NEW { // Check the recycle list first. return aPresContext->AllocateFromShell(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 nsStyleContext::Destroy() { // Get the pres context from our rule node. nsRefPtr presContext = mRuleNode->GetPresContext(); // Call our destructor. this->~nsStyleContext(); // Don't let the memory be freed, since it will be recycled // instead. Don't call the global operator delete. presContext->FreeToShell(sizeof(nsStyleContext), this); } already_AddRefed NS_NewStyleContext(nsStyleContext* aParentContext, nsIAtom* aPseudoTag, nsCSSPseudoElements::Type aPseudoType, nsRuleNode* aRuleNode, nsPresContext* aPresContext) { nsStyleContext* context = new (aPresContext) nsStyleContext(aParentContext, aPseudoTag, aPseudoType, aRuleNode, aPresContext); if (context) context->AddRef(); return context; } static nscolor ExtractColor(nsCSSProperty aProperty, nsStyleContext *aStyleContext) { nsStyleAnimation::Value val; #ifdef DEBUG PRBool success = #endif nsStyleAnimation::ExtractComputedValue(aProperty, aStyleContext, val); NS_ABORT_IF_FALSE(success, "aProperty must be extractable by nsStyleAnimation"); return val.GetColorValue(); } struct ColorIndexSet { PRUint8 colorIndex, alphaIndex; }; static const ColorIndexSet gVisitedIndices[2] = { { 0, 0 }, { 1, 0 } }; nscolor nsStyleContext::GetVisitedDependentColor(nsCSSProperty aProperty) { NS_ASSERTION(aProperty == eCSSProperty_color || aProperty == eCSSProperty_background_color || aProperty == eCSSProperty_border_top_color || aProperty == eCSSProperty_border_right_color_value || aProperty == eCSSProperty_border_bottom_color || aProperty == eCSSProperty_border_left_color_value || aProperty == eCSSProperty_outline_color || aProperty == eCSSProperty__moz_column_rule_color || aProperty == eCSSProperty_fill || aProperty == eCSSProperty_stroke, "we need to add to nsStyleContext::CalcStyleDifference"); nscolor colors[2]; colors[0] = ExtractColor(aProperty, this); nsStyleContext *visitedStyle = this->GetStyleIfVisited(); if (!visitedStyle) { return colors[0]; } colors[1] = ExtractColor(aProperty, visitedStyle); return nsStyleContext::CombineVisitedColors(colors, this->RelevantLinkVisited()); } /* static */ nscolor nsStyleContext::CombineVisitedColors(nscolor *aColors, PRBool aLinkIsVisited) { if (NS_GET_A(aColors[1]) == 0) { // If the style-if-visited is transparent, then just use the // unvisited style rather than using the (meaningless) color // components of the visited style along with a potentially // non-transparent alpha value. aLinkIsVisited = PR_FALSE; } // NOTE: We want this code to have as little timing dependence as // possible on whether this->RelevantLinkVisited() is true. const ColorIndexSet &set = gVisitedIndices[aLinkIsVisited ? 1 : 0]; nscolor colorColor = aColors[set.colorIndex]; nscolor alphaColor = aColors[set.alphaIndex]; return NS_RGBA(NS_GET_R(colorColor), NS_GET_G(colorColor), NS_GET_B(colorColor), NS_GET_A(alphaColor)); }