diff --git a/mozilla/content/base/src/nsStyleContext.cpp b/mozilla/content/base/src/nsStyleContext.cpp index f10e153777a..2c4f254771a 100644 --- a/mozilla/content/base/src/nsStyleContext.cpp +++ b/mozilla/content/base/src/nsStyleContext.cpp @@ -33,6 +33,7 @@ * 03/20/2000 IBM Corp. BiDi - ability to change the default direction of the browser * */ + #include "nsIStyleContext.h" #include "nsIMutableStyleContext.h" #include "nsStyleConsts.h" @@ -103,6 +104,26 @@ static nscoord CalcCoord(const nsStyleCoord& aCoord, const nscoord* aEnumTable, PRInt32 aNumEnums); +// XXX this is here to support deprecated calc spacing methods only +static nscoord kBorderWidths[3]; // contain the twips values for thin, medium and thick +static void InitBorderWidths(nsIPresContext* aPresContext) +{ + // XXX support kBorderWidhts until deprecated methods are removed + static PRBool kWidthsInitialized = PR_FALSE; + if (! kWidthsInitialized) { + kWidthsInitialized = PR_TRUE; + + float pixelsToTwips = 20.0f; + if (aPresContext) { + aPresContext->GetPixelsToTwips(&pixelsToTwips); + } + kBorderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); + kBorderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); + kBorderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); + } +} + + // EnsureBlockDisplay: // - if the display value (argument) is not a block-type // then we set it to a valid block display value @@ -220,6 +241,10 @@ PRUint32 StyleFontImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleColor // @@ -348,14 +373,13 @@ PRUint32 StyleColorImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } -// -------------------- -// nsStyleSpacing -// -// XXX this is here to support deprecated calc spacing methods only -static nscoord kBorderWidths[3]; -static PRBool kWidthsInitialized = PR_FALSE; +#ifdef XP_MAC +#pragma mark - +#endif -nsStyleSpacing::nsStyleSpacing(void) { } +#define BORDER_COLOR_DEFINED 0x80 +#define BORDER_COLOR_SPECIAL 0x40 +#define BORDER_STYLE_MASK 0x3F #define NS_SPACING_MARGIN 0 #define NS_SPACING_PADDING 1 @@ -379,21 +403,26 @@ static nscoord CalcSideFor(const nsIFrame* aFrame, const nsStyleCoord& aCoord, nsIStyleContext* parentContext; parentFrame->GetStyleContext(&parentContext); if (nsnull != parentContext) { - const nsStyleSpacing* parentSpacing = (const nsStyleSpacing*)parentContext->GetStyleData(eStyleStruct_Spacing); - nsMargin parentMargin; + nsMargin parentSide; switch (aSpacing) { - case NS_SPACING_MARGIN: parentSpacing->CalcMarginFor(parentFrame, parentMargin); + case NS_SPACING_MARGIN: + const nsStyleMargin* parentMargin = (const nsStyleMargin*)parentContext->GetStyleData(eStyleStruct_Margin); + parentMargin->CalcMarginFor(parentFrame, parentSide); break; - case NS_SPACING_PADDING: parentSpacing->CalcPaddingFor(parentFrame, parentMargin); + case NS_SPACING_PADDING: + const nsStylePadding* parentPadding = (const nsStylePadding*)parentContext->GetStyleData(eStyleStruct_Padding); + parentPadding->CalcPaddingFor(parentFrame, parentSide); break; - case NS_SPACING_BORDER: parentSpacing->CalcBorderFor(parentFrame, parentMargin); + case NS_SPACING_BORDER: + const nsStyleBorder* parentBorder = (const nsStyleBorder*)parentContext->GetStyleData(eStyleStruct_Border); + parentBorder->CalcBorderFor(parentFrame, parentSide); break; } switch (aSide) { - case NS_SIDE_LEFT: result = parentMargin.left; break; - case NS_SIDE_TOP: result = parentMargin.top; break; - case NS_SIDE_RIGHT: result = parentMargin.right; break; - case NS_SIDE_BOTTOM: result = parentMargin.bottom; break; + case NS_SIDE_LEFT: result = parentSide.left; break; + case NS_SIDE_TOP: result = parentSide.top; break; + case NS_SIDE_RIGHT: result = parentSide.right; break; + case NS_SIDE_BOTTOM: result = parentSide.bottom; break; } NS_RELEASE(parentContext); } @@ -466,248 +495,6 @@ static void CalcSidesFor(const nsIFrame* aFrame, const nsStyleSides& aSides, aEnumTable, aNumEnums); } -void nsStyleSpacing::CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const -{ - if (mHasCachedMargin) { - aMargin = mCachedMargin; - } else { - CalcSidesFor(aFrame, mMargin, NS_SPACING_MARGIN, nsnull, 0, aMargin); - } -} - -void nsStyleSpacing::CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const -{ - if (mHasCachedPadding) { - aPadding = mCachedPadding; - } else { - CalcSidesFor(aFrame, mPadding, NS_SPACING_PADDING, nsnull, 0, aPadding); - } -} - -void nsStyleSpacing::CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const -{ - if (mHasCachedBorder) { - aBorder = mCachedBorder; - } else { - CalcSidesFor(aFrame, mBorder, NS_SPACING_BORDER, kBorderWidths, 3, aBorder); - } -} - -void nsStyleSpacing::CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const -{ - if (mHasCachedPadding && mHasCachedBorder) { - aBorderPadding = mCachedBorderPadding; - } else { - nsMargin border; - CalcBorderFor(aFrame, border); - CalcPaddingFor(aFrame, aBorderPadding); - aBorderPadding += border; - } -} - -PRBool nsStyleSpacing::GetMargin(nsMargin& aMargin) const -{ - if (mHasCachedMargin) { - aMargin = mCachedMargin; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetPadding(nsMargin& aPadding) const -{ - if (mHasCachedPadding) { - aPadding = mCachedPadding; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetBorder(nsMargin& aBorder) const -{ - if (mHasCachedBorder) { - aBorder = mCachedBorder; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetBorderPadding(nsMargin& aBorderPadding) const -{ - if (mHasCachedPadding && mHasCachedBorder) { - aBorderPadding = mCachedBorderPadding; - return PR_TRUE; - } - return PR_FALSE; -} - -#define BORDER_COLOR_DEFINED 0x80 -#define BORDER_COLOR_SPECIAL 0x40 -#define BORDER_STYLE_MASK 0x3F - - -PRUint8 nsStyleSpacing::GetBorderStyle(PRUint8 aSide) const -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - return (mBorderStyle[aSide] & BORDER_STYLE_MASK); -} - -void nsStyleSpacing::SetBorderStyle(PRUint8 aSide, PRUint8 aStyle) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] &= ~BORDER_STYLE_MASK; - mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK); - -} - -PRBool nsStyleSpacing::GetBorderColor(PRUint8 aSide, nscolor& aColor) const -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0) { - aColor = mBorderColor[aSide]; - return PR_TRUE; - } - return PR_FALSE; -} - -void nsStyleSpacing::SetBorderColor(PRUint8 aSide, nscolor aColor) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderColor[aSide] = aColor; - mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL; - mBorderStyle[aSide] |= BORDER_COLOR_DEFINED; -} - -void nsStyleSpacing::SetBorderTransparent(PRUint8 aSide) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); -} - -void nsStyleSpacing::UnsetBorderColor(PRUint8 aSide) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] &= BORDER_STYLE_MASK; -} - -PRBool nsStyleSpacing::GetOutlineWidth(nscoord& aWidth) const -{ - if (mHasCachedOutline) { - aWidth = mCachedOutlineWidth; - return PR_TRUE; - } - return PR_FALSE; -} - -PRUint8 nsStyleSpacing::GetOutlineStyle(void) const -{ - return (mOutlineStyle & BORDER_STYLE_MASK); -} - -void nsStyleSpacing::SetOutlineStyle(PRUint8 aStyle) -{ - mOutlineStyle &= ~BORDER_STYLE_MASK; - mOutlineStyle |= (aStyle & BORDER_STYLE_MASK); -} - -PRBool nsStyleSpacing::GetOutlineColor(nscolor& aColor) const -{ - if ((mOutlineStyle & BORDER_COLOR_SPECIAL) == 0) { - aColor = mOutlineColor; - return PR_TRUE; - } - return PR_FALSE; -} - -void nsStyleSpacing::SetOutlineColor(nscolor aColor) -{ - mOutlineColor = aColor; - mOutlineStyle &= ~BORDER_COLOR_SPECIAL; - mOutlineStyle |= BORDER_COLOR_DEFINED; -} - -void nsStyleSpacing::SetOutlineInvert(void) -{ - mOutlineStyle |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); -} - - - -struct StyleSpacingImpl: public nsStyleSpacing { - StyleSpacingImpl(void) - : nsStyleSpacing() - {} - - void ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext); - void SetFrom(const nsStyleSpacing& aSource); - void CopyTo(nsStyleSpacing& aDest) const; - PRBool IsBorderSideVisible(PRUint8 aSide) const; - void RecalcData(nsIPresContext* aPresContext, nscolor color); - PRInt32 CalcDifference(const StyleSpacingImpl& aOther) const; - PRUint32 ComputeCRC32(PRUint32 aCrc) const; - -}; - -void StyleSpacingImpl::ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext) -{ - // XXX support kBorderWidhts until deprecated methods are removed - if (! kWidthsInitialized) { - float pixelsToTwips = 20.0f; - if (aPresContext) { - aPresContext->GetPixelsToTwips(&pixelsToTwips); - } - kBorderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); - kBorderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); - kBorderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); - kWidthsInitialized = PR_TRUE; - } - - - // spacing values not inherited - mMargin.Reset(); - mPadding.Reset(); - nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); - mBorder.SetLeft(medium); - mBorder.SetTop(medium); - mBorder.SetRight(medium); - mBorder.SetBottom(medium); - - mBorderStyle[0] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[1] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[2] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[3] = NS_STYLE_BORDER_STYLE_NONE; - - - mBorderColor[0] = NS_RGB(0, 0, 0); - mBorderColor[1] = NS_RGB(0, 0, 0); - mBorderColor[2] = NS_RGB(0, 0, 0); - mBorderColor[3] = NS_RGB(0, 0, 0); - - mBorderRadius.Reset(); - mOutlineRadius.Reset(); - - mOutlineWidth = medium; - mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE; - mOutlineColor = NS_RGB(0, 0, 0); - - mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT; - - mHasCachedMargin = PR_FALSE; - mHasCachedPadding = PR_FALSE; - mHasCachedBorder = PR_FALSE; - mHasCachedOutline = PR_FALSE; -} - -void StyleSpacingImpl::SetFrom(const nsStyleSpacing& aSource) -{ - nsCRT::memcpy((nsStyleSpacing*)this, &aSource, sizeof(nsStyleSpacing)); -} - -void StyleSpacingImpl::CopyTo(nsStyleSpacing& aDest) const -{ - nsCRT::memcpy(&aDest, (const nsStyleSpacing*)this, sizeof(nsStyleSpacing)); -} - static PRBool IsFixedData(const nsStyleSides& aSides, PRBool aEnumOK) { return PRBool(IsFixedUnit(aSides.GetLeftUnit(), aEnumOK) && @@ -740,24 +527,64 @@ static nscoord CalcCoord(const nsStyleCoord& aCoord, return 0; } -PRBool StyleSpacingImpl::IsBorderSideVisible(PRUint8 aSide) const + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleMargin::nsStyleMargin(void) { } + +PRBool nsStyleMargin::GetMargin(nsMargin& aMargin) const { - PRUint8 borderStyle = GetBorderStyle(aSide); - return ((borderStyle != NS_STYLE_BORDER_STYLE_NONE) - && (borderStyle != NS_STYLE_BORDER_STYLE_HIDDEN)); + if (mHasCachedMargin) { + aMargin = mCachedMargin; + return PR_TRUE; + } + return PR_FALSE; } -void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) +void nsStyleMargin::CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const { - nscoord borderWidths[3]; - float pixelsToTwips = 20.0f; - if (aPresContext) { - aPresContext->GetPixelsToTwips(&pixelsToTwips); + if (mHasCachedMargin) { + aMargin = mCachedMargin; + } else { + CalcSidesFor(aFrame, mMargin, NS_SPACING_MARGIN, nsnull, 0, aMargin); } - borderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); - borderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); - borderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); +} +struct StyleMarginImpl: public nsStyleMargin { + StyleMarginImpl(void) + : nsStyleMargin() + {} + + void ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleMargin& aSource); + void CopyTo(nsStyleMargin& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StyleMarginImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleMarginImpl::ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mMargin.Reset(); + mHasCachedMargin = PR_FALSE; +} + +void StyleMarginImpl::SetFrom(const nsStyleMargin& aSource) +{ + nsCRT::memcpy((nsStyleMargin*)this, &aSource, sizeof(nsStyleMargin)); +} + +void StyleMarginImpl::CopyTo(nsStyleMargin& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleMargin*)this, sizeof(nsStyleMargin)); +} + +void StyleMarginImpl::RecalcData(void) +{ if (IsFixedData(mMargin, PR_FALSE)) { nsStyleCoord coord; mCachedMargin.left = CalcCoord(mMargin.GetLeft(coord), nsnull, 0); @@ -770,7 +597,86 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) else { mHasCachedMargin = PR_FALSE; } +} +PRInt32 StyleMarginImpl::CalcDifference(const StyleMarginImpl& aOther) const +{ + if (mMargin == aOther.mMargin) { + return NS_STYLE_HINT_NONE; + } + return NS_STYLE_HINT_REFLOW; +} + +PRUint32 StyleMarginImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mMargin); + crc = AccumulateCRC(crc,(const char *)&mHasCachedMargin,sizeof(mHasCachedMargin)); + crc = StyleMarginCRC(crc,&mCachedMargin); +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStylePadding::nsStylePadding(void) { } + +PRBool nsStylePadding::GetPadding(nsMargin& aPadding) const +{ + if (mHasCachedPadding) { + aPadding = mCachedPadding; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStylePadding::CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const +{ + if (mHasCachedPadding) { + aPadding = mCachedPadding; + } else { + CalcSidesFor(aFrame, mPadding, NS_SPACING_PADDING, nsnull, 0, aPadding); + } +} + +struct StylePaddingImpl: public nsStylePadding { + StylePaddingImpl(void) + : nsStylePadding() + {} + + void ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStylePadding& aSource); + void CopyTo(nsStylePadding& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StylePaddingImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StylePaddingImpl::ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mPadding.Reset(); + mHasCachedPadding = PR_FALSE; +} + +void StylePaddingImpl::SetFrom(const nsStylePadding& aSource) +{ + nsCRT::memcpy((nsStylePadding*)this, &aSource, sizeof(nsStylePadding)); +} + +void StylePaddingImpl::CopyTo(nsStylePadding& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStylePadding*)this, sizeof(nsStylePadding)); +} + +void StylePaddingImpl::RecalcData(void) +{ if (IsFixedData(mPadding, PR_FALSE)) { nsStyleCoord coord; mCachedPadding.left = CalcCoord(mPadding.GetLeft(coord), nsnull, 0); @@ -783,7 +689,177 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) else { mHasCachedPadding = PR_FALSE; } +} +PRInt32 StylePaddingImpl::CalcDifference(const StylePaddingImpl& aOther) const +{ + if (mPadding == aOther.mPadding) { + return NS_STYLE_HINT_NONE; + } + return NS_STYLE_HINT_REFLOW; +} + +PRUint32 StylePaddingImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mPadding); + crc = AccumulateCRC(crc,(const char *)&mHasCachedPadding,sizeof(mHasCachedPadding)); + crc = StyleMarginCRC(crc,&mCachedPadding); +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleBorderPadding::nsStyleBorderPadding(void) { mHasCachedBorderPadding = PR_FALSE; } + +PRBool nsStyleBorderPadding::GetBorderPadding(nsMargin& aBorderPadding) const { + if (mHasCachedBorderPadding) { + aBorderPadding = mCachedBorderPadding; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleBorderPadding::SetBorderPadding(nsMargin aBorderPadding) { + mCachedBorderPadding = aBorderPadding; + mHasCachedBorderPadding = PR_TRUE; +} + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleBorder::nsStyleBorder(void) { } + +PRBool nsStyleBorder::GetBorder(nsMargin& aBorder) const +{ + if (mHasCachedBorder) { + aBorder = mCachedBorder; + return PR_TRUE; + } + return PR_FALSE; +} + +PRUint8 nsStyleBorder::GetBorderStyle(PRUint8 aSide) const +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + return (mBorderStyle[aSide] & BORDER_STYLE_MASK); +} + +void nsStyleBorder::SetBorderStyle(PRUint8 aSide, PRUint8 aStyle) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] &= ~BORDER_STYLE_MASK; + mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK); + +} + +PRBool nsStyleBorder::GetBorderColor(PRUint8 aSide, nscolor& aColor) const +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0) { + aColor = mBorderColor[aSide]; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleBorder::SetBorderColor(PRUint8 aSide, nscolor aColor) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderColor[aSide] = aColor; + mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL; + mBorderStyle[aSide] |= BORDER_COLOR_DEFINED; +} + +void nsStyleBorder::SetBorderTransparent(PRUint8 aSide) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); +} + +void nsStyleBorder::UnsetBorderColor(PRUint8 aSide) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] &= BORDER_STYLE_MASK; +} + +void nsStyleBorder::CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const +{ + if (mHasCachedBorder) { + aBorder = mCachedBorder; + } else { + CalcSidesFor(aFrame, mBorder, NS_SPACING_BORDER, kBorderWidths, 3, aBorder); + } +} + +struct StyleBorderImpl: public nsStyleBorder { + StyleBorderImpl(void) + : nsStyleBorder() + {} + + void ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleBorder& aSource); + void CopyTo(nsStyleBorder& aDest) const; + PRBool IsBorderSideVisible(PRUint8 aSide) const; + void RecalcData(nscolor color); + PRInt32 CalcDifference(const StyleBorderImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleBorderImpl::ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); + mBorder.SetLeft(medium); + mBorder.SetTop(medium); + mBorder.SetRight(medium); + mBorder.SetBottom(medium); + + mBorderStyle[0] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[1] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[2] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[3] = NS_STYLE_BORDER_STYLE_NONE; + + + mBorderColor[0] = NS_RGB(0, 0, 0); + mBorderColor[1] = NS_RGB(0, 0, 0); + mBorderColor[2] = NS_RGB(0, 0, 0); + mBorderColor[3] = NS_RGB(0, 0, 0); + + mBorderRadius.Reset(); + + mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT; + + mHasCachedBorder = PR_FALSE; +} + +void StyleBorderImpl::SetFrom(const nsStyleBorder& aSource) +{ + nsCRT::memcpy((nsStyleBorder*)this, &aSource, sizeof(nsStyleBorder)); +} + +void StyleBorderImpl::CopyTo(nsStyleBorder& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleBorder*)this, sizeof(nsStyleBorder)); +} + +PRBool StyleBorderImpl::IsBorderSideVisible(PRUint8 aSide) const +{ + PRUint8 borderStyle = GetBorderStyle(aSide); + return ((borderStyle != NS_STYLE_BORDER_STYLE_NONE) + && (borderStyle != NS_STYLE_BORDER_STYLE_HIDDEN)); +} + +void StyleBorderImpl::RecalcData(nscolor aColor) +{ if (((!IsBorderSideVisible(NS_SIDE_LEFT))|| IsFixedUnit(mBorder.GetLeftUnit(), PR_TRUE)) && ((!IsBorderSideVisible(NS_SIDE_TOP)) || @@ -797,25 +873,25 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) mCachedBorder.left = 0; } else { - mCachedBorder.left = CalcCoord(mBorder.GetLeft(coord), borderWidths, 3); + mCachedBorder.left = CalcCoord(mBorder.GetLeft(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_TOP)) { mCachedBorder.top = 0; } else { - mCachedBorder.top = CalcCoord(mBorder.GetTop(coord), borderWidths, 3); + mCachedBorder.top = CalcCoord(mBorder.GetTop(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_RIGHT)) { mCachedBorder.right = 0; } else { - mCachedBorder.right = CalcCoord(mBorder.GetRight(coord), borderWidths, 3); + mCachedBorder.right = CalcCoord(mBorder.GetRight(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_BOTTOM)) { mCachedBorder.bottom = 0; } else { - mCachedBorder.bottom = CalcCoord(mBorder.GetBottom(coord), borderWidths, 3); + mCachedBorder.bottom = CalcCoord(mBorder.GetBottom(coord), kBorderWidths, 3); } mHasCachedBorder = PR_TRUE; } @@ -823,11 +899,6 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) mHasCachedBorder = PR_FALSE; } - if (mHasCachedBorder && mHasCachedPadding) { - mCachedBorderPadding = mCachedPadding; - mCachedBorderPadding += mCachedBorder; - } - if ((mBorderStyle[NS_SIDE_TOP] & BORDER_COLOR_DEFINED) == 0) { mBorderColor[NS_SIDE_TOP] = aColor; } @@ -840,27 +911,11 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) if ((mBorderStyle[NS_SIDE_RIGHT] & BORDER_COLOR_DEFINED) == 0) { mBorderColor[NS_SIDE_RIGHT] = aColor; } - - if ((NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) || - IsFixedUnit(mOutlineWidth.GetUnit(), PR_TRUE)) { - if (NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) { - mCachedOutlineWidth = 0; - } - else { - mCachedOutlineWidth = CalcCoord(mOutlineWidth, borderWidths, 3); - } - mHasCachedOutline = PR_TRUE; - } - else { - mHasCachedOutline = PR_FALSE; - } } -PRInt32 StyleSpacingImpl::CalcDifference(const StyleSpacingImpl& aOther) const +PRInt32 StyleBorderImpl::CalcDifference(const StyleBorderImpl& aOther) const { - if ((mMargin == aOther.mMargin) && - (mPadding == aOther.mPadding) && - (mBorder == aOther.mBorder) && + if ((mBorder == aOther.mBorder) && (mFloatEdge == aOther.mFloatEdge)) { PRInt32 ix; for (ix = 0; ix < 4; ix++) { @@ -879,46 +934,158 @@ PRInt32 StyleSpacingImpl::CalcDifference(const StyleSpacingImpl& aOther) const if (mBorderRadius != aOther.mBorderRadius) { return NS_STYLE_HINT_VISUAL; } - if ((mOutlineWidth != aOther.mOutlineWidth) || - (mOutlineStyle != aOther.mOutlineStyle) || - (mOutlineColor != aOther.mOutlineColor) || - (mOutlineRadius != aOther.mOutlineRadius)) { - return NS_STYLE_HINT_VISUAL; // XXX: should be VISUAL: see bugs 9809 and 9816 - } return NS_STYLE_HINT_NONE; } return NS_STYLE_HINT_REFLOW; } -PRUint32 StyleSpacingImpl::ComputeCRC32(PRUint32 aCrc) const +PRUint32 StyleBorderImpl::ComputeCRC32(PRUint32 aCrc) const { PRUint32 crc = aCrc; #ifdef COMPUTE_STYLEDATA_CRC - crc = StyleSideCRC(crc,&mMargin); - crc = StyleSideCRC(crc,&mPadding); crc = StyleSideCRC(crc,&mBorder); crc = StyleSideCRC(crc,&mBorderRadius); - crc = StyleSideCRC(crc,&mOutlineRadius); - crc = StyleCoordCRC(crc,&mOutlineWidth); crc = AccumulateCRC(crc,(const char *)&mFloatEdge,sizeof(mFloatEdge)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedMargin,sizeof(mHasCachedMargin)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedPadding,sizeof(mHasCachedPadding)); crc = AccumulateCRC(crc,(const char *)&mHasCachedBorder,sizeof(mHasCachedBorder)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedOutline,sizeof(mHasCachedOutline)); - crc = StyleMarginCRC(crc,&mCachedMargin); - crc = StyleMarginCRC(crc,&mCachedPadding); crc = StyleMarginCRC(crc,&mCachedBorder); - crc = StyleMarginCRC(crc,&mCachedBorderPadding); - crc = AccumulateCRC(crc,(const char *)&mCachedOutlineWidth,sizeof(mCachedOutlineWidth)); crc = AccumulateCRC(crc,(const char *)mBorderStyle,sizeof(mBorderStyle)); // array of 4 elements crc = AccumulateCRC(crc,(const char *)mBorderColor,sizeof(mBorderColor)); // array ... +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleOutline::nsStyleOutline(void) { } + +PRBool nsStyleOutline::GetOutlineWidth(nscoord& aWidth) const +{ + if (mHasCachedOutline) { + aWidth = mCachedOutlineWidth; + return PR_TRUE; + } + return PR_FALSE; +} + +PRUint8 nsStyleOutline::GetOutlineStyle(void) const +{ + return (mOutlineStyle & BORDER_STYLE_MASK); +} + +void nsStyleOutline::SetOutlineStyle(PRUint8 aStyle) +{ + mOutlineStyle &= ~BORDER_STYLE_MASK; + mOutlineStyle |= (aStyle & BORDER_STYLE_MASK); +} + +PRBool nsStyleOutline::GetOutlineColor(nscolor& aColor) const +{ + if ((mOutlineStyle & BORDER_COLOR_SPECIAL) == 0) { + aColor = mOutlineColor; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleOutline::SetOutlineColor(nscolor aColor) +{ + mOutlineColor = aColor; + mOutlineStyle &= ~BORDER_COLOR_SPECIAL; + mOutlineStyle |= BORDER_COLOR_DEFINED; +} + +void nsStyleOutline::SetOutlineInvert(void) +{ + mOutlineStyle |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); +} + +struct StyleOutlineImpl: public nsStyleOutline { + StyleOutlineImpl(void) + : nsStyleOutline() + {} + + void ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleOutline& aSource); + void CopyTo(nsStyleOutline& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StyleOutlineImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleOutlineImpl::ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mOutlineRadius.Reset(); + + nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); + mOutlineWidth = medium; + mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE; + mOutlineColor = NS_RGB(0, 0, 0); + + mHasCachedOutline = PR_FALSE; +} + +void StyleOutlineImpl::SetFrom(const nsStyleOutline& aSource) +{ + nsCRT::memcpy((nsStyleOutline*)this, &aSource, sizeof(nsStyleOutline)); +} + +void StyleOutlineImpl::CopyTo(nsStyleOutline& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleOutline*)this, sizeof(nsStyleOutline)); +} + +void StyleOutlineImpl::RecalcData(void) +{ + if ((NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) || + IsFixedUnit(mOutlineWidth.GetUnit(), PR_TRUE)) { + if (NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) { + mCachedOutlineWidth = 0; + } + else { + mCachedOutlineWidth = CalcCoord(mOutlineWidth, kBorderWidths, 3); + } + mHasCachedOutline = PR_TRUE; + } + else { + mHasCachedOutline = PR_FALSE; + } +} + +PRInt32 StyleOutlineImpl::CalcDifference(const StyleOutlineImpl& aOther) const +{ + if ((mOutlineWidth != aOther.mOutlineWidth) || + (mOutlineStyle != aOther.mOutlineStyle) || + (mOutlineColor != aOther.mOutlineColor) || + (mOutlineRadius != aOther.mOutlineRadius)) { + return NS_STYLE_HINT_VISUAL; // XXX: should be VISUAL: see bugs 9809 and 9816 + } + return NS_STYLE_HINT_NONE; +} + +PRUint32 StyleOutlineImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mOutlineRadius); + crc = StyleCoordCRC(crc,&mOutlineWidth); + crc = AccumulateCRC(crc,(const char *)&mHasCachedOutline,sizeof(mHasCachedOutline)); + crc = AccumulateCRC(crc,(const char *)&mCachedOutlineWidth,sizeof(mCachedOutlineWidth)); crc = AccumulateCRC(crc,(const char *)&mOutlineStyle,sizeof(mOutlineStyle)); crc = AccumulateCRC(crc,(const char *)&mOutlineColor,sizeof(mOutlineColor)); #endif return crc; } +#ifdef XP_MAC +#pragma mark - +#endif // -------------------- // nsStyleList // @@ -988,6 +1155,10 @@ PRUint32 StyleListImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStylePosition // @@ -1073,6 +1244,10 @@ PRUint32 StylePositionImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleText // @@ -1172,6 +1347,10 @@ PRUint32 StyleTextImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleDisplay // @@ -1285,6 +1464,10 @@ PRUint32 StyleDisplayImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleTable // @@ -1393,6 +1576,9 @@ PRUint32 StyleTableImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStyleContent @@ -1754,6 +1940,9 @@ PRUint32 StyleContentImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStyleUserInterface @@ -1861,6 +2050,9 @@ PRUint32 StyleUserInterfaceImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStylePrint @@ -1953,6 +2145,9 @@ PRUint32 StylePrintImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //---------------------------------------------------------------------- @@ -1997,20 +2192,6 @@ void StyleColorImplLog::ResetFrom(const nsStyleColor* aParent, nsIPresContext* a mSetFromParent = (aParent != nsnull); } -// StyleSpacingImpl mSpacing; -struct StyleSpacingImplLog: public StyleSpacingImpl { - void ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext); - StyleSpacingImpl mInternalSpacing; - bool mSetFromParent; -}; - -void StyleSpacingImplLog::ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext) -{ - StyleSpacingImpl::ResetFrom(aParent, aPresContext); - CopyTo(mInternalSpacing); - mSetFromParent = (aParent != nsnull); -} - // StyleListImpl mList; struct StyleListImplLog: public StyleListImpl { void ResetFrom(const nsStyleList* aParent, nsIPresContext* aPresContext); @@ -2123,6 +2304,65 @@ void StylePrintImplLog::ResetFrom(const nsStylePrint* aParent, nsIPresContext* a mSetFromParent = (aParent != nsnull); } +// StyleMarginImpl mMargin; +struct StyleMarginImplLog: public StyleMarginImpl { + void ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext); + StyleMarginImpl mInternalMargin; + bool mSetFromParent; +}; + +void StyleMarginImplLog::ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext) +{ + StyleMarginImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalMargin); + mSetFromParent = (aParent != nsnull); +} + +// StylePaddingImpl mPadding; +struct StylePaddingImplLog: public StylePaddingImpl { + void ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext); + StylePaddingImpl mInternalPadding; + bool mSetFromParent; +}; + +void StylePaddingImplLog::ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext) +{ + StylePaddingImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalPadding); + mSetFromParent = (aParent != nsnull); +} + +// StyleBorderImpl mBorder; +struct StyleBorderImplLog: public StyleBorderImpl { + void ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext); + StyleBorderImpl mInternalBorder; + bool mSetFromParent; +}; + +void StyleBorderImplLog::ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext) +{ + StyleBorderImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalBorder); + mSetFromParent = (aParent != nsnull); +} + +// StyleOutlineImpl mOutline; +struct StyleOutlineImplLog: public StyleOutlineImpl { + void ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext); + StyleOutlineImpl mInternalOutline; + bool mSetFromParent; +}; + +void StyleOutlineImplLog::ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext) +{ + StyleOutlineImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalOutline); + mSetFromParent = (aParent != nsnull); +} + +#ifdef XP_MAC +#pragma mark - +#endif #endif // LOG_STYLE_STRUCTS //======================== @@ -2159,7 +2399,6 @@ private: // all data and methods private: only friends have access #ifdef LOG_STYLE_STRUCTS StyleFontImplLog mFont; StyleColorImplLog mColor; - StyleSpacingImplLog mSpacing; StyleListImplLog mList; StylePositionImplLog mPosition; StyleTextImplLog mText; @@ -2168,10 +2407,13 @@ private: // all data and methods private: only friends have access StyleContentImplLog mContent; StyleUserInterfaceImplLog mUserInterface; StylePrintImplLog mPrint; + StyleMarginImplLog mMargin; + StylePaddingImplLog mPadding; + StyleBorderImplLog mBorder; + StyleOutlineImplLog mOutline; #else StyleFontImpl mFont; StyleColorImpl mColor; - StyleSpacingImpl mSpacing; StyleListImpl mList; StylePositionImpl mPosition; StyleTextImpl mText; @@ -2180,6 +2422,10 @@ private: // all data and methods private: only friends have access StyleContentImpl mContent; StyleUserInterfaceImpl mUserInterface; StylePrintImpl mPrint; + StyleMarginImpl mMargin; + StylePaddingImpl mPadding; + StyleBorderImpl mBorder; + StyleOutlineImpl mOutline; #endif PRUint32 mRefCnt; @@ -2277,7 +2523,7 @@ static bool IsTimeToDumpStyleStructs() } static void LogStyleStructs(nsStyleContextData* aStyleContextData) { -#define max_structs eStyleStruct_Print +#define max_structs eStyleStruct_Max static unsigned long totalCount = 0; static unsigned long defaultStruct[max_structs]; @@ -2302,7 +2548,6 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) switch (index) { case eStyleStruct_Font: printf("eStyleStruct_Font "); sizeOfStruct = sizeof(StyleFontImpl); break; case eStyleStruct_Color: printf("eStyleStruct_Color "); sizeOfStruct = sizeof(StyleColorImpl); break; - case eStyleStruct_Spacing: printf("eStyleStruct_Spacing "); sizeOfStruct = sizeof(StyleSpacingImpl); break; case eStyleStruct_List: printf("eStyleStruct_List "); sizeOfStruct = sizeof(StyleListImpl); break; case eStyleStruct_Position: printf("eStyleStruct_Position "); sizeOfStruct = sizeof(StylePositionImpl); break; case eStyleStruct_Text: printf("eStyleStruct_Text "); sizeOfStruct = sizeof(StyleTextImpl); break; @@ -2311,6 +2556,10 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) case eStyleStruct_Content: printf("eStyleStruct_Content "); sizeOfStruct = sizeof(StyleContentImpl); break; case eStyleStruct_UserInterface: printf("eStyleStruct_UserInterface "); sizeOfStruct = sizeof(StyleUserInterfaceImpl); break; case eStyleStruct_Print: printf("eStyleStruct_Print "); sizeOfStruct = sizeof(StylePrintImpl); break; + case eStyleStruct_Margin: printf("eStyleStruct_Margin "); sizeOfStruct = sizeof(StyleMarginImpl); break; + case eStyleStruct_Padding: printf("eStyleStruct_Padding "); sizeOfStruct = sizeof(StylePaddingImpl); break; + case eStyleStruct_Border: printf("eStyleStruct_Border "); sizeOfStruct = sizeof(StyleBorderImpl); break; + case eStyleStruct_Outline: printf("eStyleStruct_Outline "); sizeOfStruct = sizeof(StyleOutlineImpl); break; } short percentDefault = (totalCount == 0 ? 0 : ((100 * defaultStruct[i]) / totalCount)); short percentFromParent = (defaultStruct[i] == 0 ? 0 : ((100 * setFromParent[i]) / defaultStruct[i])); @@ -2366,13 +2615,6 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) setFromParent[i]++; } break; - case eStyleStruct_Spacing: - if (aStyleContextData->mSpacing.CalcDifference(aStyleContextData->mSpacing.mInternalSpacing) == NS_STYLE_HINT_NONE) { - defaultStruct[i]++; - if (aStyleContextData->mSpacing.mSetFromParent) - setFromParent[i]++; - } - break; case eStyleStruct_List: if (aStyleContextData->mList.CalcDifference(aStyleContextData->mList.mInternalList) == NS_STYLE_HINT_NONE) { defaultStruct[i]++; @@ -2429,6 +2671,34 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) setFromParent[i]++; } break; + case eStyleStruct_Margin: + if (aStyleContextData->mMargin.CalcDifference(aStyleContextData->mMargin.mInternalMargin) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mMargin.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Padding: + if (aStyleContextData->mPadding.CalcDifference(aStyleContextData->mPadding.mInternalPadding) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mPadding.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Border: + if (aStyleContextData->mBorder.CalcDifference(aStyleContextData->mBorder.mInternalBorder) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mBorder.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Outline: + if (aStyleContextData->mOutline.CalcDifference(aStyleContextData->mOutline.mInternalOutline) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mOutline.mSetFromParent) + setFromParent[i]++; + } + break; } } @@ -2463,7 +2733,6 @@ PRUint32 nsStyleContextData::ComputeCRC32(PRUint32 aCrc) const // have each style struct compute its own CRC, propogating the previous value... crc = mFont.ComputeCRC32(crc); crc = mColor.ComputeCRC32(crc); - crc = mSpacing.ComputeCRC32(crc); crc = mList.ComputeCRC32(crc); crc = mPosition.ComputeCRC32(crc); crc = mText.ComputeCRC32(crc); @@ -2472,6 +2741,10 @@ PRUint32 nsStyleContextData::ComputeCRC32(PRUint32 aCrc) const crc = mContent.ComputeCRC32(crc); crc = mUserInterface.ComputeCRC32(crc); crc = mPrint.ComputeCRC32(crc); + crc = mMargin.ComputeCRC32(crc); + crc = mPadding.ComputeCRC32(crc); + crc = mBorder.ComputeCRC32(crc); + crc = mOutline.ComputeCRC32(crc); #else crc = 0; #endif @@ -2535,6 +2808,7 @@ public: virtual void ForceUnique(void); virtual void RecalcAutomaticData(nsIPresContext* aPresContext); + virtual void CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const; NS_IMETHOD CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PRBool aStopAtFirstDifference = PR_FALSE) const; #ifdef SHARE_STYLECONTEXTS @@ -2596,7 +2870,6 @@ protected: // the style data... StyleFontImpl mFont; StyleColorImpl mColor; - StyleSpacingImpl mSpacing; StyleListImpl mList; StylePositionImpl mPosition; StyleTextImpl mText; @@ -2605,6 +2878,10 @@ protected: StyleContentImpl mContent; StyleUserInterfaceImpl mUserInterface; StylePrintImpl mPrint; + StyleMarginImpl mMargin; + StylePaddingImpl mPadding; + StyleBorderImpl mBorder; + StyleOutlineImpl mOutline; #endif // #ifdef SHARE_STYLECONTEXTS @@ -2623,6 +2900,10 @@ static PRBool HashStyleRule(nsISupports* aRule, void* aData) return PR_TRUE; } +#ifdef XP_MAC +#pragma mark - +#endif + StyleContextImpl::StyleContextImpl(nsIStyleContext* aParent, nsIAtom* aPseudoTag, nsISupportsArray* aRules, @@ -2653,6 +2934,8 @@ StyleContextImpl::StyleContextImpl(nsIStyleContext* aParent, NS_IF_ADDREF(mPseudoTag); NS_IF_ADDREF(mRules); + InitBorderWidths(aPresContext); + mNextSibling = this; mPrevSibling = this; if (nsnull != mParent) { @@ -2916,7 +3199,9 @@ PRUint32 StyleContextImpl::HashValue(void) const //========================================================================================================= #ifdef DEBUG -//#define LOG_GET_STYLE_DATA_CALLS // define this to get stats on the calls to GetStyleData() //XXX pierre +// define this to get statistics on the number of calls +// to GetStyleData() and their depth in the Style tree. +//#define LOG_GET_STYLE_DATA_CALLS //XXX pierre #endif #ifdef LOG_GET_STYLE_DATA_CALLS @@ -2995,7 +3280,6 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon switch (i%max_structs + 1) { case eStyleStruct_Font: printf("eStyleStruct_Font "); break; case eStyleStruct_Color: printf("eStyleStruct_Color "); break; - case eStyleStruct_Spacing: printf("eStyleStruct_Spacing "); break; case eStyleStruct_List: printf("eStyleStruct_List "); break; case eStyleStruct_Position: printf("eStyleStruct_Position "); break; case eStyleStruct_Text: printf("eStyleStruct_Text "); break; @@ -3004,6 +3288,10 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon case eStyleStruct_Content: printf("eStyleStruct_Content "); break; case eStyleStruct_UserInterface: printf("eStyleStruct_UserInterface "); break; case eStyleStruct_Print: printf("eStyleStruct_Print "); break; + case eStyleStruct_Margin: printf("eStyleStruct_Margin "); break; + case eStyleStruct_Padding: printf("eStyleStruct_Padding "); break; + case eStyleStruct_Border: printf("eStyleStruct_Border "); break; + case eStyleStruct_Outline: printf("eStyleStruct_Outline "); break; } short percent = 100*calls[i]/totalCalls; short avdepth = calls[i] == 0 ? 0 : round(float(depth[i])/float(calls[i])); @@ -3076,7 +3364,6 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon #endif // LOG_GET_STYLE_DATA_CALLS //========================================================================================================= - const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) { #ifdef LOG_GET_STYLE_DATA_CALLS @@ -3092,9 +3379,6 @@ const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) case eStyleStruct_Color: result = & GETSCDATA(Color); break; - case eStyleStruct_Spacing: - result = & GETSCDATA(Spacing); - break; case eStyleStruct_List: result = & GETSCDATA(List); break; @@ -3119,6 +3403,18 @@ const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) case eStyleStruct_Print: result = & GETSCDATA(Print); break; + case eStyleStruct_Margin: + result = & GETSCDATA(Margin); + break; + case eStyleStruct_Padding: + result = & GETSCDATA(Padding); + break; + case eStyleStruct_Border: + result = & GETSCDATA(Border); + break; + case eStyleStruct_Outline: + result = & GETSCDATA(Outline); + break; default: NS_ERROR("Invalid style struct id"); break; @@ -3141,9 +3437,6 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) case eStyleStruct_Color: result = & GETSCDATA(Color); break; - case eStyleStruct_Spacing: - result = & GETSCDATA(Spacing); - break; case eStyleStruct_List: result = & GETSCDATA(List); break; @@ -3168,6 +3461,18 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) case eStyleStruct_Print: result = & GETSCDATA(Print); break; + case eStyleStruct_Margin: + result = & GETSCDATA(Margin); + break; + case eStyleStruct_Padding: + result = & GETSCDATA(Padding); + break; + case eStyleStruct_Border: + result = & GETSCDATA(Border); + break; + case eStyleStruct_Outline: + result = & GETSCDATA(Outline); + break; default: NS_ERROR("Invalid style struct id"); break; @@ -3181,6 +3486,18 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) return result; } +void StyleContextImpl::CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const +{ + nsMargin border, padding; + if (!GETSCDATA(Border).GetBorder(border)) { + GETSCDATA(Border).CalcBorderFor(aFrame, border); + } + if (!GETSCDATA(Padding).GetPadding(padding)) { + GETSCDATA(Padding).CalcPaddingFor(aFrame, padding); + } + aBorderPadding = border + padding; +} + NS_IMETHODIMP StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const { @@ -3192,9 +3509,6 @@ StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const case eStyleStruct_Color: GETSCDATA(Color).CopyTo((nsStyleColor&)aStruct); break; - case eStyleStruct_Spacing: - GETSCDATA(Spacing).CopyTo((nsStyleSpacing&)aStruct); - break; case eStyleStruct_List: GETSCDATA(List).CopyTo((nsStyleList&)aStruct); break; @@ -3219,6 +3533,27 @@ StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const case eStyleStruct_Print: GETSCDATA(Print).CopyTo((nsStylePrint&)aStruct); break; + case eStyleStruct_Margin: + GETSCDATA(Margin).CopyTo((nsStyleMargin&)aStruct); + break; + case eStyleStruct_Padding: + GETSCDATA(Padding).CopyTo((nsStylePadding&)aStruct); + break; + case eStyleStruct_Border: + GETSCDATA(Border).CopyTo((nsStyleBorder&)aStruct); + break; + case eStyleStruct_Outline: + GETSCDATA(Outline).CopyTo((nsStyleOutline&)aStruct); + break; + case eStyleStruct_BorderPaddingShortcut: + nsMargin border, padding; + if (GETSCDATA(Border).GetBorder(border)) { + if (GETSCDATA(Padding).GetPadding(padding)) { + border += padding; + ((nsStyleBorderPadding&)aStruct).SetBorderPadding(border); + } + } + break; default: NS_ERROR("Invalid style struct id"); result = NS_ERROR_INVALID_ARG; @@ -3238,9 +3573,6 @@ StyleContextImpl::SetStyle(nsStyleStructID aSID, const nsStyleStruct& aStruct) case eStyleStruct_Color: GETSCDATA(Color).SetFrom((const nsStyleColor&)aStruct); break; - case eStyleStruct_Spacing: - GETSCDATA(Spacing).SetFrom((const nsStyleSpacing&)aStruct); - break; case eStyleStruct_List: GETSCDATA(List).SetFrom((const nsStyleList&)aStruct); break; @@ -3265,6 +3597,18 @@ StyleContextImpl::SetStyle(nsStyleStructID aSID, const nsStyleStruct& aStruct) case eStyleStruct_Print: GETSCDATA(Print).SetFrom((const nsStylePrint&)aStruct); break; + case eStyleStruct_Margin: + GETSCDATA(Margin).SetFrom((const nsStyleMargin&)aStruct); + break; + case eStyleStruct_Padding: + GETSCDATA(Padding).SetFrom((const nsStylePadding&)aStruct); + break; + case eStyleStruct_Border: + GETSCDATA(Border).SetFrom((const nsStyleBorder&)aStruct); + break; + case eStyleStruct_Outline: + GETSCDATA(Outline).SetFrom((const nsStyleOutline&)aStruct); + break; default: NS_ERROR("Invalid style struct id"); result = NS_ERROR_INVALID_ARG; @@ -3313,7 +3657,6 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) if (nsnull != mParent) { GETSCDATA(Font).ResetFrom(&(mParent->GETSCDATA(Font)), aPresContext); GETSCDATA(Color).ResetFrom(&(mParent->GETSCDATA(Color)), aPresContext); - GETSCDATA(Spacing).ResetFrom(&(mParent->GETSCDATA(Spacing)), aPresContext); GETSCDATA(List).ResetFrom(&(mParent->GETSCDATA(List)), aPresContext); GETSCDATA(Position).ResetFrom(&(mParent->GETSCDATA(Position)), aPresContext); GETSCDATA(Text).ResetFrom(&(mParent->GETSCDATA(Text)), aPresContext); @@ -3322,11 +3665,14 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(&(mParent->GETSCDATA(Content)), aPresContext); GETSCDATA(UserInterface).ResetFrom(&(mParent->GETSCDATA(UserInterface)), aPresContext); GETSCDATA(Print).ResetFrom(&(mParent->GETSCDATA(Print)), aPresContext); + GETSCDATA(Margin).ResetFrom(&(mParent->GETSCDATA(Margin)), aPresContext); + GETSCDATA(Padding).ResetFrom(&(mParent->GETSCDATA(Padding)), aPresContext); + GETSCDATA(Border).ResetFrom(&(mParent->GETSCDATA(Border)), aPresContext); + GETSCDATA(Outline).ResetFrom(&(mParent->GETSCDATA(Outline)), aPresContext); } else { GETSCDATA(Font).ResetFrom(nsnull, aPresContext); GETSCDATA(Color).ResetFrom(nsnull, aPresContext); - GETSCDATA(Spacing).ResetFrom(nsnull, aPresContext); GETSCDATA(List).ResetFrom(nsnull, aPresContext); GETSCDATA(Position).ResetFrom(nsnull, aPresContext); GETSCDATA(Text).ResetFrom(nsnull, aPresContext); @@ -3335,6 +3681,10 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(nsnull, aPresContext); GETSCDATA(UserInterface).ResetFrom(nsnull, aPresContext); GETSCDATA(Print).ResetFrom(nsnull, aPresContext); + GETSCDATA(Margin).ResetFrom(nsnull, aPresContext); + GETSCDATA(Padding).ResetFrom(nsnull, aPresContext); + GETSCDATA(Border).ResetFrom(nsnull, aPresContext); + GETSCDATA(Outline).ResetFrom(nsnull, aPresContext); } PRUint32 cnt = 0; @@ -3404,7 +3754,6 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Font).ResetFrom(nsnull, aPresContext); } GETSCDATA(Color).ResetFrom(nsnull, aPresContext); - GETSCDATA(Spacing).ResetFrom(nsnull, aPresContext); GETSCDATA(List).ResetFrom(nsnull, aPresContext); GETSCDATA(Text).ResetFrom(nsnull, aPresContext); GETSCDATA(Position).ResetFrom(nsnull, aPresContext); @@ -3413,6 +3762,10 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(nsnull, aPresContext); GETSCDATA(UserInterface).ResetFrom(nsnull, aPresContext); GETSCDATA(Print).ResetFrom(nsnull, aPresContext); + GETSCDATA(Margin).ResetFrom(nsnull, aPresContext); + GETSCDATA(Padding).ResetFrom(nsnull, aPresContext); + GETSCDATA(Border).ResetFrom(nsnull, aPresContext); + GETSCDATA(Outline).ResetFrom(nsnull, aPresContext); GETSCDATA(Display).mVisible = visible; GETSCDATA(Display).mDirection = direction; GETSCDATA(Display).mLanguage = language; @@ -3497,7 +3850,10 @@ void StyleContextImpl::RecalcAutomaticData(nsIPresContext* aPresContext) if (NS_FAILED(EnsureStyleData(aPresContext))) { return /*NS_FAILURE*/; } - GETSCDATA(Spacing).RecalcData(aPresContext, GETSCDATA(Color).mColor); + GETSCDATA(Margin).RecalcData(); + GETSCDATA(Padding).RecalcData(); + GETSCDATA(Border).RecalcData(GETSCDATA(Color).mColor); + GETSCDATA(Outline).RecalcData(); } NS_IMETHODIMP @@ -3520,13 +3876,6 @@ StyleContextImpl::CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PR } } if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; - if (aHint < NS_STYLE_HINT_MAX) { - hint = GETSCDATA(Spacing).CalcDifference(other->GETSCDATA(Spacing)); - if (aHint < hint) { - aHint = hint; - } - } - if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; if (aHint < NS_STYLE_HINT_MAX) { hint = GETSCDATA(List).CalcDifference(other->GETSCDATA(List)); if (aHint < hint) { @@ -3582,6 +3931,34 @@ StyleContextImpl::CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PR aHint = hint; } } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Margin).CalcDifference(other->GETSCDATA(Margin)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Padding).CalcDifference(other->GETSCDATA(Padding)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Border).CalcDifference(other->GETSCDATA(Border)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Outline).CalcDifference(other->GETSCDATA(Outline)); + if (aHint < hint) { + aHint = hint; + } + } } return NS_OK; } @@ -3865,8 +4242,6 @@ void StyleContextImpl::SizeOf(nsISizeOfHandler *aSizeOfHandler, PRUint32 &aSize) totalSize += (long)sizeof(GETSCDATA(Font)); printf( " - StyleColorImpl: %ld\n", (long)sizeof(GETSCDATA(Color)) ); totalSize += (long)sizeof(GETSCDATA(Color)); - printf( " - StyleSpacingImpl: %ld\n", (long)sizeof(GETSCDATA(Spacing)) ); - totalSize += (long)sizeof(GETSCDATA(Spacing)); printf( " - StyleListImpl: %ld\n", (long)sizeof(GETSCDATA(List)) ); totalSize += (long)sizeof(GETSCDATA(List)); printf( " - StylePositionImpl: %ld\n", (long)sizeof(GETSCDATA(Position)) ); @@ -3883,6 +4258,14 @@ void StyleContextImpl::SizeOf(nsISizeOfHandler *aSizeOfHandler, PRUint32 &aSize) totalSize += (long)sizeof(GETSCDATA(UserInterface)); printf( " - StylePrintImpl: %ld\n", (long)sizeof(GETSCDATA(Print))); totalSize += (long)sizeof(GETSCDATA(Print)); + printf( " - StyleMarginImpl: %ld\n", (long)sizeof(GETSCDATA(Margin))); + totalSize += (long)sizeof(GETSCDATA(Margin)); + printf( " - StylePaddingImpl: %ld\n", (long)sizeof(GETSCDATA(Padding))); + totalSize += (long)sizeof(GETSCDATA(Padding)); + printf( " - StyleBorderImpl: %ld\n", (long)sizeof(GETSCDATA(Border))); + totalSize += (long)sizeof(GETSCDATA(Border)); + printf( " - StyleOutlineImpl: %ld\n", (long)sizeof(GETSCDATA(Outline))); + totalSize += (long)sizeof(GETSCDATA(Outline)); printf( " - Total: %ld\n", (long)totalSize); printf( "*************************************\n"); } @@ -3982,23 +4365,23 @@ void StyleContextImpl::DumpRegressionData(nsIPresContext* aPresContext, FILE* ou NS_ConvertUCS2toUTF8(GETSCDATA(Color).mCursorImage).get(), GETSCDATA(Color).mOpacity); - // SPACING + // SPACING (ie. margin, padding, border, outline) IndentBy(out,aIndent); fprintf(out, "\n"); // LIST diff --git a/mozilla/content/html/content/src/nsGenericHTMLElement.cpp b/mozilla/content/html/content/src/nsGenericHTMLElement.cpp index c4eff0bce19..11daa218e35 100644 --- a/mozilla/content/html/content/src/nsGenericHTMLElement.cpp +++ b/mozilla/content/html/content/src/nsGenericHTMLElement.cpp @@ -715,28 +715,28 @@ nsGenericHTMLElement::GetOffsetRect(nsRect& aRect, } // For the origin, add in the border for the frame - const nsStyleSpacing* spacing; + const nsStyleBorder* border; nsStyleCoord coord; - frame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); + frame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + if (border) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); } } // And subtract out the border for the parent if (parent) { - const nsStyleSpacing* parentSpacing; - parent->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)parentSpacing); - if (parentSpacing) { - if (eStyleUnit_Coord == parentSpacing->mBorder.GetLeftUnit()) { - origin.x -= parentSpacing->mBorder.GetLeft(coord).GetCoordValue(); + const nsStyleBorder* parentBorder; + parent->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)parentBorder); + if (parentBorder) { + if (eStyleUnit_Coord == parentBorder->mBorder.GetLeftUnit()) { + origin.x -= parentBorder->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == parentSpacing->mBorder.GetTopUnit()) { - origin.y -= parentSpacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == parentBorder->mBorder.GetTopUnit()) { + origin.y -= parentBorder->mBorder.GetTop(coord).GetCoordValue(); } } } @@ -2911,8 +2911,8 @@ nsGenericHTMLElement::MapImageAttributesInto(const nsIHTMLMappedAttributes* aAtt aPresContext->GetScaledPixelsToTwips(&p2t); nsStylePosition* pos = (nsStylePosition*) aContext->GetMutableStyleData(eStyleStruct_Position); - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); // width: value aAttributes->GetAttribute(nsHTMLAtoms::width, value); @@ -2939,13 +2939,13 @@ nsGenericHTMLElement::MapImageAttributesInto(const nsIHTMLMappedAttributes* aAtt if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), p2t); nsStyleCoord c(twips); - spacing->mMargin.SetLeft(c); - spacing->mMargin.SetRight(c); + margin->mMargin.SetLeft(c); + margin->mMargin.SetRight(c); } else if (value.GetUnit() == eHTMLUnit_Percent) { nsStyleCoord c(value.GetPercentValue(), eStyleUnit_Percent); - spacing->mMargin.SetLeft(c); - spacing->mMargin.SetRight(c); + margin->mMargin.SetLeft(c); + margin->mMargin.SetRight(c); } // vspace: value @@ -2953,13 +2953,13 @@ nsGenericHTMLElement::MapImageAttributesInto(const nsIHTMLMappedAttributes* aAtt if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), p2t); nsStyleCoord c(twips); - spacing->mMargin.SetTop(c); - spacing->mMargin.SetBottom(c); + margin->mMargin.SetTop(c); + margin->mMargin.SetBottom(c); } else if (value.GetUnit() == eHTMLUnit_Percent) { nsStyleCoord c(value.GetPercentValue(), eStyleUnit_Percent); - spacing->mMargin.SetTop(c); - spacing->mMargin.SetBottom(c); + margin->mMargin.SetTop(c); + margin->mMargin.SetBottom(c); } } @@ -2990,21 +2990,21 @@ nsGenericHTMLElement::MapImageAlignAttributeInto(const nsIHTMLMappedAttributes* aContext->GetMutableStyleData(eStyleStruct_Display); nsStyleText* text = (nsStyleText*) aContext->GetMutableStyleData(eStyleStruct_Text); - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); float p2t; aPresContext->GetScaledPixelsToTwips(&p2t); nsStyleCoord three(NSIntPixelsToTwips(3, p2t)); switch (align) { case NS_STYLE_TEXT_ALIGN_LEFT: display->mFloats = NS_STYLE_FLOAT_LEFT; - spacing->mMargin.SetLeft(three); - spacing->mMargin.SetRight(three); + margin->mMargin.SetLeft(three); + margin->mMargin.SetRight(three); break; case NS_STYLE_TEXT_ALIGN_RIGHT: display->mFloats = NS_STYLE_FLOAT_RIGHT; - spacing->mMargin.SetLeft(three); - spacing->mMargin.SetRight(three); + margin->mMargin.SetLeft(three); + margin->mMargin.SetRight(three); break; default: text->mVerticalAlign.SetIntValue(align, eStyleUnit_Enumerated); @@ -3053,38 +3053,39 @@ nsGenericHTMLElement::MapImageBorderAttributeInto(const nsIHTMLMappedAttributes* // Fixup border-padding sums: subtract out the old size and then // add in the new size. - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + nsStyleCoord coord; coord.SetCoordValue(twips); - spacing->mBorder.SetTop(coord); - spacing->mBorder.SetRight(coord); - spacing->mBorder.SetBottom(coord); - spacing->mBorder.SetLeft(coord); + border->mBorder.SetTop(coord); + border->mBorder.SetRight(coord); + border->mBorder.SetBottom(coord); + border->mBorder.SetLeft(coord); - spacing->SetBorderStyle(0,NS_STYLE_BORDER_STYLE_SOLID); - spacing->SetBorderStyle(1,NS_STYLE_BORDER_STYLE_SOLID); - spacing->SetBorderStyle(2,NS_STYLE_BORDER_STYLE_SOLID); - spacing->SetBorderStyle(3,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(0,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(1,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(2,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(3,NS_STYLE_BORDER_STYLE_SOLID); // Use supplied colors if provided, otherwise use color for border // color if (nsnull != aBorderColors) { - spacing->SetBorderColor(0, aBorderColors[0]); - spacing->SetBorderColor(1, aBorderColors[1]); - spacing->SetBorderColor(2, aBorderColors[2]); - spacing->SetBorderColor(3, aBorderColors[3]); + border->SetBorderColor(0, aBorderColors[0]); + border->SetBorderColor(1, aBorderColors[1]); + border->SetBorderColor(2, aBorderColors[2]); + border->SetBorderColor(3, aBorderColors[3]); } else { // Color is inherited from "color" const nsStyleColor* styleColor = (const nsStyleColor*) aContext->GetStyleData(eStyleStruct_Color); nscolor color = styleColor->mColor; - spacing->SetBorderColor(0, color); - spacing->SetBorderColor(1, color); - spacing->SetBorderColor(2, color); - spacing->SetBorderColor(3, color); + border->SetBorderColor(0, color); + border->SetBorderColor(1, color); + border->SetBorderColor(2, color); + border->SetBorderColor(3, color); } } diff --git a/mozilla/content/html/content/src/nsHTMLBodyElement.cpp b/mozilla/content/html/content/src/nsHTMLBodyElement.cpp index 066c79c28b1..b0f7073b946 100644 --- a/mozilla/content/html/content/src/nsHTMLBodyElement.cpp +++ b/mozilla/content/html/content/src/nsHTMLBodyElement.cpp @@ -293,9 +293,9 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, nsIPresContext* aPresContext) { if (mPart) { - nsStyleSpacing* styleSpacing = (nsStyleSpacing*)(aContext->GetMutableStyleData(eStyleStruct_Spacing)); + nsStyleMargin* marginStyle = (nsStyleMargin*)(aContext->GetMutableStyleData(eStyleStruct_Margin)); - if (nsnull != styleSpacing) { + if (nsnull != marginStyle) { nsHTMLValue value; PRInt32 attrCount; float p2t; @@ -313,8 +313,8 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, bodyMarginWidth = 0; } nsStyleCoord widthCoord(bodyMarginWidth); - styleSpacing->mMargin.SetLeft(widthCoord); - styleSpacing->mMargin.SetRight(widthCoord); + marginStyle->mMargin.SetLeft(widthCoord); + marginStyle->mMargin.SetRight(widthCoord); } mPart->GetHTMLAttribute(nsHTMLAtoms::marginheight, value); @@ -325,8 +325,8 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, } nsStyleCoord heightCoord(bodyMarginHeight); - styleSpacing->mMargin.SetTop(heightCoord); - styleSpacing->mMargin.SetBottom(heightCoord); + marginStyle->mMargin.SetTop(heightCoord); + marginStyle->mMargin.SetBottom(heightCoord); } } @@ -363,14 +363,14 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, if ((0 > bodyMarginWidth) && (frameMarginWidth >= 0)) { nsStyleCoord widthCoord(frameMarginWidth); - styleSpacing->mMargin.SetLeft(widthCoord); - styleSpacing->mMargin.SetRight(widthCoord); + marginStyle->mMargin.SetLeft(widthCoord); + marginStyle->mMargin.SetRight(widthCoord); } if ((0 > bodyMarginHeight) && (frameMarginHeight >= 0)) { nsStyleCoord heightCoord(frameMarginHeight); - styleSpacing->mMargin.SetTop(heightCoord); - styleSpacing->mMargin.SetBottom(heightCoord); + marginStyle->mMargin.SetTop(heightCoord); + marginStyle->mMargin.SetBottom(heightCoord); } } NS_RELEASE(container); diff --git a/mozilla/content/html/content/src/nsHTMLHRElement.cpp b/mozilla/content/html/content/src/nsHTMLHRElement.cpp index 7aa089ed8e9..acf8bae427d 100644 --- a/mozilla/content/html/content/src/nsHTMLHRElement.cpp +++ b/mozilla/content/html/content/src/nsHTMLHRElement.cpp @@ -207,22 +207,22 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, aAttributes->GetAttribute(nsHTMLAtoms::align, value); if (eHTMLUnit_Enumerated == value.GetUnit()) { // Map align attribute into auto side margins - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); nsStyleCoord otto(eStyleUnit_Auto); nsStyleCoord zero(nscoord(0)); switch (value.GetIntValue()) { case NS_STYLE_TEXT_ALIGN_LEFT: - spacing->mMargin.SetLeft(zero); - spacing->mMargin.SetRight(otto); + margin->mMargin.SetLeft(zero); + margin->mMargin.SetRight(otto); break; case NS_STYLE_TEXT_ALIGN_RIGHT: - spacing->mMargin.SetLeft(otto); - spacing->mMargin.SetRight(zero); + margin->mMargin.SetLeft(otto); + margin->mMargin.SetRight(zero); break; case NS_STYLE_TEXT_ALIGN_CENTER: - spacing->mMargin.SetLeft(otto); - spacing->mMargin.SetRight(otto); + margin->mMargin.SetLeft(otto); + margin->mMargin.SetRight(otto); break; } } diff --git a/mozilla/content/html/content/src/nsHTMLIFrameElement.cpp b/mozilla/content/html/content/src/nsHTMLIFrameElement.cpp index 512bc71739f..2f1c1824d2d 100644 --- a/mozilla/content/html/content/src/nsHTMLIFrameElement.cpp +++ b/mozilla/content/html/content/src/nsHTMLIFrameElement.cpp @@ -314,15 +314,15 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if (NS_STYLE_FRAME_0 == frameborder || NS_STYLE_FRAME_NO == frameborder || NS_STYLE_FRAME_OFF == frameborder) { - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); - if (spacing) { + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + if (border) { nsStyleCoord coord; coord.SetCoordValue(0); - spacing->mBorder.SetTop(coord); - spacing->mBorder.SetRight(coord); - spacing->mBorder.SetBottom(coord); - spacing->mBorder.SetLeft(coord); + border->mBorder.SetTop(coord); + border->mBorder.SetRight(coord); + border->mBorder.SetBottom(coord); + border->mBorder.SetLeft(coord); } } } diff --git a/mozilla/content/html/content/src/nsHTMLInputElement.cpp b/mozilla/content/html/content/src/nsHTMLInputElement.cpp index e5741abf8a0..e37d6ec8a45 100644 --- a/mozilla/content/html/content/src/nsHTMLInputElement.cpp +++ b/mozilla/content/html/content/src/nsHTMLInputElement.cpp @@ -1323,23 +1323,23 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, nscoord pad = NSIntPixelsToTwips(3, p2t); // add left and right padding around the radio button via css - nsStyleSpacing* spacing = (nsStyleSpacing*) aContext->GetMutableStyleData(eStyleStruct_Spacing); - if (eStyleUnit_Null == spacing->mMargin.GetLeftUnit()) { + nsStyleMargin* margin = (nsStyleMargin*) aContext->GetMutableStyleData(eStyleStruct_Margin); + if (eStyleUnit_Null == margin->mMargin.GetLeftUnit()) { nsStyleCoord left(pad); - spacing->mMargin.SetLeft(left); + margin->mMargin.SetLeft(left); } - if (eStyleUnit_Null == spacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Null == margin->mMargin.GetRightUnit()) { nsStyleCoord right(NSIntPixelsToTwips(5, p2t)); - spacing->mMargin.SetRight(right); + margin->mMargin.SetRight(right); } // add bottom padding if backward mode // XXX why isn't this working? nsCompatibility mode; aPresContext->GetCompatibilityMode(&mode); if (eCompatibility_NavQuirks == mode) { - if (eStyleUnit_Null == spacing->mMargin.GetBottomUnit()) { + if (eStyleUnit_Null == margin->mMargin.GetBottomUnit()) { nsStyleCoord bottom(pad); - spacing->mMargin.SetBottom(bottom); + margin->mMargin.SetBottom(bottom); } } break; diff --git a/mozilla/content/html/content/src/nsHTMLTableElement.cpp b/mozilla/content/html/content/src/nsHTMLTableElement.cpp index c6f5dedf16c..686d1b2f09f 100644 --- a/mozilla/content/html/content/src/nsHTMLTableElement.cpp +++ b/mozilla/content/html/content/src/nsHTMLTableElement.cpp @@ -1063,13 +1063,13 @@ static void MapTableFrameInto(const nsIHTMLMappedAttributes* aAttributes, nsIMutableStyleContext* aContext, nsIPresContext* aPresContext, - nsStyleSpacing* aSpacing, + nsStyleBorder* aBorder, PRUint8 aBorderStyle) { // set up defaults for (PRInt32 sideX = NS_SIDE_TOP; sideX <= NS_SIDE_LEFT; sideX++) { - if (aSpacing->GetBorderStyle(sideX) == NS_STYLE_BORDER_STYLE_NONE) { - aSpacing->SetBorderStyle(sideX, aBorderStyle); + if (aBorder->GetBorderStyle(sideX) == NS_STYLE_BORDER_STYLE_NONE) { + aBorder->SetBorderStyle(sideX, aBorderStyle); } } @@ -1082,44 +1082,44 @@ MapTableFrameInto(const nsIHTMLMappedAttributes* aAttributes, switch (frameValue.GetIntValue()) { case NS_STYLE_TABLE_FRAME_NONE: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_ABOVE: - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_BELOW: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_HSIDES: - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_LEFT: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_RIGHT: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_VSIDES: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); break; // BOX and BORDER are ignored, the caller has already set all the border sides @@ -1151,8 +1151,8 @@ MapTableBorderInto(const nsIHTMLMappedAttributes* aAttributes, } if (borderValue.GetUnit() != eHTMLUnit_Null) { - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); nsStyleTable *tableStyle = (nsStyleTable*) aContext->GetMutableStyleData(eStyleStruct_Table); nsStyleCoord twips; @@ -1183,12 +1183,12 @@ MapTableBorderInto(const nsIHTMLMappedAttributes* aAttributes, } // by default, set all border sides to the specified width - spacing->mBorder.SetTop(twips); - spacing->mBorder.SetRight(twips); - spacing->mBorder.SetBottom(twips); - spacing->mBorder.SetLeft(twips); + border->mBorder.SetTop(twips); + border->mBorder.SetRight(twips); + border->mBorder.SetBottom(twips); + border->mBorder.SetLeft(twips); // then account for the frame attribute - MapTableFrameInto(aAttributes, aContext, aPresContext, spacing, + MapTableFrameInto(aAttributes, aContext, aPresContext, border, aBorderStyle); } } @@ -1219,14 +1219,14 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, aPresContext->GetPixelsToTwips(&p2t); nscoord onePixel = NSIntPixelsToTwips(1, p2t); - nsStyleSpacing* spacingStyle = (nsStyleSpacing*)aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* borderStyleData = (nsStyleBorder*)aContext->GetMutableStyleData(eStyleStruct_Border); nsStyleCoord width; width.SetCoordValue(onePixel); - spacingStyle->mBorder.SetTop(width); - spacingStyle->mBorder.SetLeft(width); - spacingStyle->mBorder.SetBottom(width); - spacingStyle->mBorder.SetRight(width); + borderStyleData->mBorder.SetTop(width); + borderStyleData->mBorder.SetLeft(width); + borderStyleData->mBorder.SetBottom(width); + borderStyleData->mBorder.SetRight(width); nsCompatibility mode; aPresContext->GetCompatibilityMode(&mode); @@ -1235,10 +1235,10 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, // BG_INSET results in a border color based on background colors // used for NavQuirks only... - spacingStyle->SetBorderStyle(NS_SIDE_TOP, borderStyle); - spacingStyle->SetBorderStyle(NS_SIDE_LEFT, borderStyle); - spacingStyle->SetBorderStyle(NS_SIDE_BOTTOM, borderStyle); - spacingStyle->SetBorderStyle(NS_SIDE_RIGHT, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_TOP, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_LEFT, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_BOTTOM, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_RIGHT, borderStyle); } } else { // handle attributes for table @@ -1289,8 +1289,10 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, } } - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* borderStyleData = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + nsStyleMargin* marginStyleData = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); // default border style is the Nav4.6 extension which uses the // background color as the basis of the outset border. If the @@ -1312,10 +1314,10 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if ((eHTMLUnit_Color == value.GetUnit()) || (eHTMLUnit_ColorName == value.GetUnit())) { nscolor color = value.GetColorValue(); - spacing->SetBorderColor(0, color); - spacing->SetBorderColor(1, color); - spacing->SetBorderColor(2, color); - spacing->SetBorderColor(3, color); + borderStyleData->SetBorderColor(0, color); + borderStyleData->SetBorderColor(1, color); + borderStyleData->SetBorderColor(2, color); + borderStyleData->SetBorderColor(3, color); borderStyle = NS_STYLE_BORDER_STYLE_OUTSET; // use css outset } @@ -1330,8 +1332,8 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if ((NS_STYLE_TEXT_ALIGN_CENTER == value.GetIntValue()) || (NS_STYLE_TEXT_ALIGN_MOZ_CENTER == value.GetIntValue())) { nsStyleCoord otto(eStyleUnit_Auto); - spacing->mMargin.SetLeft(otto); - spacing->mMargin.SetRight(otto); + marginStyleData->mMargin.SetLeft(otto); + marginStyleData->mMargin.SetRight(otto); } else { nsStyleDisplay* display = (nsStyleDisplay*) @@ -1415,8 +1417,8 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), sp2t); nsStyleCoord hspace(twips); - spacing->mMargin.SetLeft(hspace); - spacing->mMargin.SetRight(hspace); + marginStyleData->mMargin.SetLeft(hspace); + marginStyleData->mMargin.SetRight(hspace); } aAttributes->GetAttribute(nsHTMLAtoms::vspace, value); @@ -1424,8 +1426,8 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), sp2t); nsStyleCoord vspace(twips); - spacing->mMargin.SetTop(vspace); - spacing->mMargin.SetBottom(vspace); + marginStyleData->mMargin.SetTop(vspace); + marginStyleData->mMargin.SetBottom(vspace); } } diff --git a/mozilla/content/html/style/src/nsCSSStyleRule.cpp b/mozilla/content/html/style/src/nsCSSStyleRule.cpp index 080ad738b15..9027baeb677 100644 --- a/mozilla/content/html/style/src/nsCSSStyleRule.cpp +++ b/mozilla/content/html/style/src/nsCSSStyleRule.cpp @@ -2253,33 +2253,41 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nsCSSMargin* ourMargin; if (NS_OK == aDeclaration->GetData(kCSSMarginSID, (nsCSSStruct**)&ourMargin)) { if (nsnull != ourMargin) { - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*)aContext->GetMutableStyleData(eStyleStruct_Margin); + nsStylePadding* padding = (nsStylePadding*)aContext->GetMutableStyleData(eStyleStruct_Padding); + nsStyleBorder* border = (nsStyleBorder*)aContext->GetMutableStyleData(eStyleStruct_Border); + nsStyleOutline* outline = (nsStyleOutline*)aContext->GetMutableStyleData(eStyleStruct_Outline); - const nsStyleSpacing* parentSpacing = spacing; + const nsStyleMargin* parentMargin = margin; + const nsStylePadding* parentPadding = padding; + const nsStyleBorder* parentBorder = border; + const nsStyleOutline* parentOutline = outline; if (nsnull != aParentContext) { - parentSpacing = (const nsStyleSpacing*)aParentContext->GetStyleData(eStyleStruct_Spacing); + parentMargin = (const nsStyleMargin*)aParentContext->GetStyleData(eStyleStruct_Margin); + parentPadding = (const nsStylePadding*)aParentContext->GetStyleData(eStyleStruct_Padding); + parentBorder = (const nsStyleBorder*)aParentContext->GetStyleData(eStyleStruct_Border); + parentOutline = (const nsStyleOutline*)aParentContext->GetStyleData(eStyleStruct_Outline); } // margin: length, percent, auto, inherit if (nsnull != ourMargin->mMargin) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mMargin.GetLeft(parentCoord); + parentMargin->mMargin.GetLeft(parentCoord); if (SetCoord(ourMargin->mMargin->mLeft, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetLeft(coord); + margin->mMargin.SetLeft(coord); } - parentSpacing->mMargin.GetTop(parentCoord); + parentMargin->mMargin.GetTop(parentCoord); if (SetCoord(ourMargin->mMargin->mTop, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetTop(coord); + margin->mMargin.SetTop(coord); } - parentSpacing->mMargin.GetRight(parentCoord); + parentMargin->mMargin.GetRight(parentCoord); if (SetCoord(ourMargin->mMargin->mRight, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetRight(coord); + margin->mMargin.SetRight(coord); } - parentSpacing->mMargin.GetBottom(parentCoord); + parentMargin->mMargin.GetBottom(parentCoord); if (SetCoord(ourMargin->mMargin->mBottom, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetBottom(coord); + margin->mMargin.SetBottom(coord); } } @@ -2287,21 +2295,21 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mPadding) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mPadding.GetLeft(parentCoord); + parentPadding->mPadding.GetLeft(parentCoord); if (SetCoord(ourMargin->mPadding->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetLeft(coord); + padding->mPadding.SetLeft(coord); } - parentSpacing->mPadding.GetTop(parentCoord); + parentPadding->mPadding.GetTop(parentCoord); if (SetCoord(ourMargin->mPadding->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetTop(coord); + padding->mPadding.SetTop(coord); } - parentSpacing->mPadding.GetRight(parentCoord); + parentPadding->mPadding.GetRight(parentCoord); if (SetCoord(ourMargin->mPadding->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetRight(coord); + padding->mPadding.SetRight(coord); } - parentSpacing->mPadding.GetBottom(parentCoord); + parentPadding->mPadding.GetBottom(parentCoord); if (SetCoord(ourMargin->mPadding->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetBottom(coord); + padding->mPadding.SetBottom(coord); } } @@ -2310,31 +2318,31 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nsStyleCoord coord; nsStyleCoord parentCoord; if (SetCoord(ourMargin->mBorderWidth->mLeft, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetLeft(coord); + border->mBorder.SetLeft(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mLeft.GetUnit()) { - spacing->mBorder.SetLeft(parentSpacing->mBorder.GetLeft(coord)); + border->mBorder.SetLeft(parentBorder->mBorder.GetLeft(coord)); } if (SetCoord(ourMargin->mBorderWidth->mTop, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetTop(coord); + border->mBorder.SetTop(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mTop.GetUnit()) { - spacing->mBorder.SetTop(parentSpacing->mBorder.GetTop(coord)); + border->mBorder.SetTop(parentBorder->mBorder.GetTop(coord)); } if (SetCoord(ourMargin->mBorderWidth->mRight, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetRight(coord); + border->mBorder.SetRight(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mRight.GetUnit()) { - spacing->mBorder.SetRight(parentSpacing->mBorder.GetRight(coord)); + border->mBorder.SetRight(parentBorder->mBorder.GetRight(coord)); } if (SetCoord(ourMargin->mBorderWidth->mBottom, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetBottom(coord); + border->mBorder.SetBottom(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mBottom.GetUnit()) { - spacing->mBorder.SetBottom(parentSpacing->mBorder.GetBottom(coord)); + border->mBorder.SetBottom(parentBorder->mBorder.GetBottom(coord)); } } @@ -2342,43 +2350,43 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mBorderStyle) { nsCSSRect* ourStyle = ourMargin->mBorderStyle; if (eCSSUnit_Enumerated == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, ourStyle->mTop.GetIntValue()); + border->SetBorderStyle(NS_SIDE_TOP, ourStyle->mTop.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, parentSpacing->GetBorderStyle(NS_SIDE_TOP)); + border->SetBorderStyle(NS_SIDE_TOP, parentBorder->GetBorderStyle(NS_SIDE_TOP)); } if (eCSSUnit_Enumerated == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, ourStyle->mRight.GetIntValue()); + border->SetBorderStyle(NS_SIDE_RIGHT, ourStyle->mRight.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, parentSpacing->GetBorderStyle(NS_SIDE_RIGHT)); + border->SetBorderStyle(NS_SIDE_RIGHT, parentBorder->GetBorderStyle(NS_SIDE_RIGHT)); } if (eCSSUnit_Enumerated == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, ourStyle->mBottom.GetIntValue()); + border->SetBorderStyle(NS_SIDE_BOTTOM, ourStyle->mBottom.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, parentSpacing->GetBorderStyle(NS_SIDE_BOTTOM)); + border->SetBorderStyle(NS_SIDE_BOTTOM, parentBorder->GetBorderStyle(NS_SIDE_BOTTOM)); } if (eCSSUnit_Enumerated == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, ourStyle->mLeft.GetIntValue()); + border->SetBorderStyle(NS_SIDE_LEFT, ourStyle->mLeft.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, parentSpacing->GetBorderStyle(NS_SIDE_LEFT)); + border->SetBorderStyle(NS_SIDE_LEFT, parentBorder->GetBorderStyle(NS_SIDE_LEFT)); } } @@ -2389,63 +2397,63 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nscolor unused = NS_RGB(0,0,0); if (eCSSUnit_Inherit == ourBorderColor->mTop.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_TOP, borderColor)) { - spacing->SetBorderColor(NS_SIDE_TOP, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_TOP, borderColor)) { + border->SetBorderColor(NS_SIDE_TOP, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_TOP); + border->SetBorderTransparent(NS_SIDE_TOP); } } else if (SetColor(ourBorderColor->mTop, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_TOP, borderColor); + border->SetBorderColor(NS_SIDE_TOP, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mTop.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_TOP); + border->SetBorderTransparent(NS_SIDE_TOP); } if (eCSSUnit_Inherit == ourBorderColor->mRight.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_RIGHT, borderColor)) { - spacing->SetBorderColor(NS_SIDE_RIGHT, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_RIGHT, borderColor)) { + border->SetBorderColor(NS_SIDE_RIGHT, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_RIGHT); + border->SetBorderTransparent(NS_SIDE_RIGHT); } } else if (SetColor(ourBorderColor->mRight, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_RIGHT, borderColor); + border->SetBorderColor(NS_SIDE_RIGHT, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mRight.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_RIGHT); + border->SetBorderTransparent(NS_SIDE_RIGHT); } if (eCSSUnit_Inherit == ourBorderColor->mBottom.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_BOTTOM, borderColor)) { - spacing->SetBorderColor(NS_SIDE_BOTTOM, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_BOTTOM, borderColor)) { + border->SetBorderColor(NS_SIDE_BOTTOM, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_BOTTOM); + border->SetBorderTransparent(NS_SIDE_BOTTOM); } } else if (SetColor(ourBorderColor->mBottom, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_BOTTOM, borderColor); + border->SetBorderColor(NS_SIDE_BOTTOM, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mBottom.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_BOTTOM); + border->SetBorderTransparent(NS_SIDE_BOTTOM); } if (eCSSUnit_Inherit == ourBorderColor->mLeft.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_LEFT, borderColor)) { - spacing->SetBorderColor(NS_SIDE_LEFT, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_LEFT, borderColor)) { + border->SetBorderColor(NS_SIDE_LEFT, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_LEFT); + border->SetBorderTransparent(NS_SIDE_LEFT); } } else if (SetColor(ourBorderColor->mLeft, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_LEFT, borderColor); + border->SetBorderColor(NS_SIDE_LEFT, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mLeft.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_LEFT); + border->SetBorderTransparent(NS_SIDE_LEFT); } } @@ -2453,21 +2461,21 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mBorderRadius) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mBorderRadius.GetLeft(parentCoord); + parentBorder->mBorderRadius.GetLeft(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetLeft(coord); + border->mBorderRadius.SetLeft(coord); } - parentSpacing->mBorderRadius.GetTop(parentCoord); + parentBorder->mBorderRadius.GetTop(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetTop(coord); + border->mBorderRadius.SetTop(coord); } - parentSpacing->mBorderRadius.GetRight(parentCoord); + parentBorder->mBorderRadius.GetRight(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetRight(coord); + border->mBorderRadius.SetRight(coord); } - parentSpacing->mBorderRadius.GetBottom(parentCoord); + parentBorder->mBorderRadius.GetBottom(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetBottom(coord); + border->mBorderRadius.SetBottom(coord); } } @@ -2475,26 +2483,26 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mOutlineRadius) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mOutlineRadius.GetLeft(parentCoord); + parentOutline->mOutlineRadius.GetLeft(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetLeft(coord); + outline->mOutlineRadius.SetLeft(coord); } - parentSpacing->mOutlineRadius.GetTop(parentCoord); + parentOutline->mOutlineRadius.GetTop(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetTop(coord); + outline->mOutlineRadius.SetTop(coord); } - parentSpacing->mOutlineRadius.GetRight(parentCoord); + parentOutline->mOutlineRadius.GetRight(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetRight(coord); + outline->mOutlineRadius.SetRight(coord); } - parentSpacing->mOutlineRadius.GetBottom(parentCoord); + parentOutline->mOutlineRadius.GetBottom(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetBottom(coord); + outline->mOutlineRadius.SetBottom(coord); } } // outline-width: length, enum, inherit - if (! SetCoord(ourMargin->mOutlineWidth, spacing->mOutlineWidth, parentSpacing->mOutlineWidth, + if (! SetCoord(ourMargin->mOutlineWidth, outline->mOutlineWidth, parentOutline->mOutlineWidth, SETCOORD_LEH, aFont->mFont, aPresContext)) { } @@ -2502,37 +2510,37 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nscolor outlineColor; nscolor unused = NS_RGB(0,0,0); if (eCSSUnit_Inherit == ourMargin->mOutlineColor.GetUnit()) { - if (parentSpacing->GetOutlineColor(outlineColor)) { - spacing->SetOutlineColor(outlineColor); + if (parentOutline->GetOutlineColor(outlineColor)) { + outline->SetOutlineColor(outlineColor); } else { - spacing->SetOutlineInvert(); + outline->SetOutlineInvert(); } } else if (SetColor(ourMargin->mOutlineColor, unused, aPresContext, outlineColor)) { - spacing->SetOutlineColor(outlineColor); + outline->SetOutlineColor(outlineColor); } else if (eCSSUnit_Enumerated == ourMargin->mOutlineColor.GetUnit()) { - spacing->SetOutlineInvert(); + outline->SetOutlineInvert(); } // outline-style: enum, none, inherit if (eCSSUnit_Enumerated == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(ourMargin->mOutlineStyle.GetIntValue()); + outline->SetOutlineStyle(ourMargin->mOutlineStyle.GetIntValue()); } else if (eCSSUnit_None == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(NS_STYLE_BORDER_STYLE_NONE); + outline->SetOutlineStyle(NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(parentSpacing->GetOutlineStyle()); + outline->SetOutlineStyle(parentOutline->GetOutlineStyle()); } // float-edge: enum, inherit if (eCSSUnit_Enumerated == ourMargin->mFloatEdge.GetUnit()) { - spacing->mFloatEdge = ourMargin->mFloatEdge.GetIntValue(); + border->mFloatEdge = ourMargin->mFloatEdge.GetIntValue(); } else if (eCSSUnit_Inherit == ourMargin->mFloatEdge.GetUnit()) { - spacing->mFloatEdge = parentSpacing->mFloatEdge; + border->mFloatEdge = parentBorder->mFloatEdge; } } } diff --git a/mozilla/content/html/style/src/nsComputedDOMStyle.cpp b/mozilla/content/html/style/src/nsComputedDOMStyle.cpp index 102170bf8b3..98898280bef 100644 --- a/mozilla/content/html/style/src/nsComputedDOMStyle.cpp +++ b/mozilla/content/html/style/src/nsComputedDOMStyle.cpp @@ -844,15 +844,15 @@ nsComputedDOMStyle::GetMargin(nsAWritableString& aMargin) nsresult GetMargins(nsIFrame *aFrame, nscoord& left, nscoord& top, nscoord& right, nscoord& bottom) { - const nsStyleSpacing* spacing; + const nsStyleBorder* border; nsStyleCoord coord; - frame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); + frame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + if (border) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); } } } @@ -1267,31 +1267,33 @@ nsComputedDOMStyle::GetAbsoluteFrameRect(nsIFrame *aFrame, nsRect& aRect) } // For the origin, add in the border for the frame - const nsStyleSpacing* spacing; + const nsStyleBorder* border; + const nsStylePadding* padding; nsStyleCoord coord; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); - aRect.width -= spacing->mBorder.GetLeft(coord).GetCoordValue(); - //aRect.width -= spacing->mMargin.GetLeft(coord).GetCoordValue(); - aRect.width -= spacing->mPadding.GetLeft(coord).GetCoordValue(); + aFrame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + aFrame->GetStyleData(eStyleStruct_Padding, (const nsStyleStruct*&)padding); + if (border && padding) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); + aRect.width -= border->mBorder.GetLeft(coord).GetCoordValue(); + //aRect.width -= margin->mMargin.GetLeft(coord).GetCoordValue(); + aRect.width -= padding->mPadding.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); - aRect.height -= spacing->mBorder.GetTop(coord).GetCoordValue(); - //aRect.height -= spacing->mMargin.GetTop(coord).GetCoordValue(); - aRect.height -= spacing->mPadding.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); + aRect.height -= border->mBorder.GetTop(coord).GetCoordValue(); + //aRect.height -= margin->mMargin.GetTop(coord).GetCoordValue(); + aRect.height -= padding->mPadding.GetTop(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetRightUnit()) { - aRect.width -= spacing->mBorder.GetRight(coord).GetCoordValue(); - //aRect.width -= spacing->mMargin.GetRight(coord).GetCoordValue(); - aRect.width -= spacing->mPadding.GetRight(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetRightUnit()) { + aRect.width -= border->mBorder.GetRight(coord).GetCoordValue(); + //aRect.width -= margin->mMargin.GetRight(coord).GetCoordValue(); + aRect.width -= padding->mPadding.GetRight(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetBottomUnit()) { - aRect.height -= spacing->mBorder.GetBottom(coord).GetCoordValue(); - //aRect.height -= spacing->mMargin.GetBottom(coord).GetCoordValue(); - aRect.height -= spacing->mPadding.GetBottom(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetBottomUnit()) { + aRect.height -= border->mBorder.GetBottom(coord).GetCoordValue(); + //aRect.height -= margin->mMargin.GetBottom(coord).GetCoordValue(); + aRect.height -= padding->mPadding.GetBottom(coord).GetCoordValue(); } } diff --git a/mozilla/content/html/style/src/nsHTMLCSSStyleSheet.cpp b/mozilla/content/html/style/src/nsHTMLCSSStyleSheet.cpp index d4aba054254..0e501fa570f 100644 --- a/mozilla/content/html/style/src/nsHTMLCSSStyleSheet.cpp +++ b/mozilla/content/html/style/src/nsHTMLCSSStyleSheet.cpp @@ -132,13 +132,13 @@ CSSFirstLineRule::MapStyleInto(nsIMutableStyleContext* aContext, parentContext = aContext->GetParent(); // Disable border - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); - if (spacing) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + if (border) { + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); } // Undo any change made to "direction" diff --git a/mozilla/layout/base/nsCSSFrameConstructor.cpp b/mozilla/layout/base/nsCSSFrameConstructor.cpp index 7175ba23e12..7138c28cd71 100644 --- a/mozilla/layout/base/nsCSSFrameConstructor.cpp +++ b/mozilla/layout/base/nsCSSFrameConstructor.cpp @@ -9490,10 +9490,10 @@ ApplyRenderingChangeToTree(nsIPresContext* aPresContext, if (! view) { // if frame has view, will already be invalidated // XXX Instead of calling this we should really be calling // Invalidate on on the nsFrame (which does this) - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + const nsStyleOutline* outline; + aFrame->GetStyleData(eStyleStruct_Outline, (const nsStyleStruct*&)outline); nscoord width; - spacing->GetOutlineWidth(width); + outline->GetOutlineWidth(width); if (width > 0) { invalidRect.Inflate(width, width); } diff --git a/mozilla/layout/base/nsCSSRendering.cpp b/mozilla/layout/base/nsCSSRendering.cpp index 88af1ae670c..ae93759c22c 100644 --- a/mozilla/layout/base/nsCSSRendering.cpp +++ b/mozilla/layout/base/nsCSSRendering.cpp @@ -740,21 +740,26 @@ nscoord xstart,xwidth,ystart,ywidth; void nsCSSRendering::DrawDashedSides(PRIntn startSide, nsIRenderingContext& aContext, const nsRect& aDirtyRect, - const nsStyleSpacing& aSpacing, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, PRBool aDoOutline, const nsRect& borderOutside, const nsRect& borderInside, PRIntn aSkipSides, nsRect* aGap) { + PRIntn dashLength; nsRect dashRect, currRect; nscoord xstart,xwidth,ystart,ywidth,temp,temp1,adjust; PRBool bSolid = PR_TRUE; float over = 0.0f; -PRUint8 style = aDoOutline?aSpacing.GetOutlineStyle():aSpacing.GetBorderStyle(startSide); PRBool skippedSide = PR_FALSE; + NS_ASSERTION((aDoOutline && aOutlineStyle) || (!aDoOutline && aBorderStyle), "null params not allowed"); + PRUint8 style = aDoOutline + ? aOutlineStyle->GetOutlineStyle() + : aBorderStyle->GetBorderStyle(startSide); // find out were x and y start if(aDirtyRect.x > borderInside.x) { @@ -777,7 +782,9 @@ PRBool skippedSide = PR_FALSE; for (PRIntn whichSide = startSide; whichSide < 4; whichSide++) { PRUint8 prevStyle = style; - style = aDoOutline?aSpacing.GetOutlineStyle():aSpacing.GetBorderStyle(whichSide); + style = aDoOutline + ? aOutlineStyle->GetOutlineStyle() + : aBorderStyle->GetBorderStyle(whichSide); if ((1<GetOutlineColor(sideColor); } else { - if (!aSpacing.GetBorderColor(whichSide, sideColor)) { + if (!aBorderStyle->GetBorderColor(whichSide, sideColor)) { continue; // side is transparent } } @@ -1488,7 +1495,7 @@ void nsCSSRendering::PaintBorder(nsIPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap, @@ -1569,7 +1576,7 @@ void nsCSSRendering::PaintBorder(nsIPresContext* aPresContext, // check for any corner that is rounded for(i=0;i<4;i++){ if(borderRadii[i] > 0){ - PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aBorderStyle,aStyleContext,aSkipSides,borderRadii,aGap,PR_FALSE); + PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,&aBorderStyle,nsnull,aStyleContext,aSkipSides,borderRadii,aGap,PR_FALSE); return; } } @@ -1600,7 +1607,7 @@ void nsCSSRendering::PaintBorder(nsIPresContext* aPresContext, } } if (cnt < 4) { - DrawDashedSides(cnt, aRenderingContext,aDirtyRect,aBorderStyle, PR_FALSE, + DrawDashedSides(cnt, aRenderingContext,aDirtyRect,&aBorderStyle,nsnull, PR_FALSE, inside, outside, aSkipSides, aGap); } @@ -1670,7 +1677,8 @@ void nsCSSRendering::PaintOutline(nsIPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, + const nsStyleOutline& aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap) @@ -1682,7 +1690,7 @@ const nsStyleColor* bgColor = nsStyleUtil::FindNonTransparentBackground(aStyleCo nscoord width; - aBorderStyle.GetOutlineWidth(width); + aOutlineStyle.GetOutlineWidth(width); if (0 == width) { // Empty outline @@ -1690,10 +1698,10 @@ nscoord width; } // get the radius for our border - aBorderStyle.mOutlineRadius.GetTop(bordStyleRadius[0]); //topleft - aBorderStyle.mOutlineRadius.GetRight(bordStyleRadius[1]); //topright - aBorderStyle.mOutlineRadius.GetBottom(bordStyleRadius[2]); //bottomright - aBorderStyle.mOutlineRadius.GetLeft(bordStyleRadius[3]); //bottomleft + aOutlineStyle.mOutlineRadius.GetTop(bordStyleRadius[0]); //topleft + aOutlineStyle.mOutlineRadius.GetRight(bordStyleRadius[1]); //topright + aOutlineStyle.mOutlineRadius.GetBottom(bordStyleRadius[2]); //bottomright + aOutlineStyle.mOutlineRadius.GetLeft(bordStyleRadius[3]); //bottomleft for(i=0;i<4;i++) { borderRadii[i] = 0; @@ -1744,18 +1752,18 @@ nscoord width; // rounded version of the border for(i=0;i<4;i++){ if(borderRadii[i] > 0){ - PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aBorderStyle,aStyleContext,aSkipSides,borderRadii,aGap,PR_TRUE); + PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,nsnull,&aOutlineStyle,aStyleContext,aSkipSides,borderRadii,aGap,PR_TRUE); aRenderingContext.PopState(clipState); return; } } - PRUint8 outlineStyle = aBorderStyle.GetOutlineStyle(); + PRUint8 outlineStyle = aOutlineStyle.GetOutlineStyle(); //see if any sides are dotted or dashed if ((outlineStyle == NS_STYLE_BORDER_STYLE_DOTTED) || (outlineStyle == NS_STYLE_BORDER_STYLE_DASHED)) { - DrawDashedSides(0, aRenderingContext, aDirtyRect, aBorderStyle, PR_TRUE, + DrawDashedSides(0, aRenderingContext, aDirtyRect, nsnull, &aOutlineStyle, PR_TRUE, outside, inside, aSkipSides, aGap); aRenderingContext.PopState(clipState); return; @@ -1771,7 +1779,7 @@ nscoord width; nscolor outlineColor; - if (aBorderStyle.GetOutlineColor(outlineColor)) { + if (aOutlineStyle.GetOutlineColor(outlineColor)) { DrawSide(aRenderingContext, NS_SIDE_BOTTOM, outlineStyle, outlineColor, @@ -2070,7 +2078,7 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aSpacing, + const nsStyleBorder& aBorder, nscoord aDX, nscoord aDY) { @@ -2125,7 +2133,7 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, nsRect paddingArea(aBorderArea); nsMargin border; - if (!aSpacing.GetBorder(border)) { + if (!aBorder.GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } paddingArea.Deflate(border); @@ -2483,10 +2491,10 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, // is rendered over the 'border' 'padding' and 'content' areas if (!transparentBG) { // get the radius for our border - aSpacing.mBorderRadius.GetTop(bordStyleRadius[0]); //topleft - aSpacing.mBorderRadius.GetRight(bordStyleRadius[1]); //topright - aSpacing.mBorderRadius.GetBottom(bordStyleRadius[2]); //bottomright - aSpacing.mBorderRadius.GetLeft(bordStyleRadius[3]); //bottomleft + aBorder.mBorderRadius.GetTop(bordStyleRadius[0]); //topleft + aBorder.mBorderRadius.GetRight(bordStyleRadius[1]); //topright + aBorder.mBorderRadius.GetBottom(bordStyleRadius[2]); //bottomright + aBorder.mBorderRadius.GetLeft(bordStyleRadius[3]); //bottomleft for(i=0;i<4;i++) { borderRadii[i] = 0; @@ -2509,7 +2517,7 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, // rounded version of the border for(i=0;i<4;i++){ if (borderRadii[i] > 0){ - PaintRoundedBackground(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aColor,aSpacing,aDX,aDY,borderRadii); + PaintRoundedBackground(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aColor,aDX,aDY,borderRadii); return; } } @@ -2563,7 +2571,6 @@ nsCSSRendering::PaintRoundedBackground(nsIPresContext* aPresContext, const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aSpacing, nscoord aDX, nscoord aDY, PRInt16 aTheRadius[4]) @@ -2652,7 +2659,8 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, PRInt16 aBorderRadius[4], @@ -2670,16 +2678,16 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, nscoord twipsPerPixel,qtwips; float p2t; - + NS_ASSERTION((aIsOutline && aOutlineStyle) || (!aIsOutline && aBorderStyle), "null params not allowed"); if (!aIsOutline) { - aBorderStyle.CalcBorderFor(aForFrame, border); + aBorderStyle->CalcBorderFor(aForFrame, border); if ((0 == border.left) && (0 == border.right) && (0 == border.top) && (0 == border.bottom)) { return; } } else { nscoord width; - if (!aBorderStyle.GetOutlineWidth(width)) { + if (!aOutlineStyle->GetOutlineWidth(width)) { return; } border.left = width; @@ -2720,7 +2728,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr2.mAnc2.x, Icr2.mAnc2.y); thePath[np++].MoveTo(Icr2.mCon.x, Icr2.mCon.y); thePath[np++].MoveTo(Icr2.mAnc1.x, Icr2.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_TOP,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_TOP,border,qtwips, aIsOutline); } // RIGHT LINE ---------------------------------------------------------------- LR.MidPointDivide(&cr2,&cr3); @@ -2740,7 +2748,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr4.mAnc2.x,Icr4.mAnc2.y); thePath[np++].MoveTo(Icr4.mCon.x, Icr4.mCon.y); thePath[np++].MoveTo(Icr4.mAnc1.x,Icr4.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_RIGHT,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_RIGHT,border,qtwips, aIsOutline); } // bottom line ---------------------------------------------------------------- @@ -2761,7 +2769,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr3.mAnc2.x, Icr3.mAnc2.y); thePath[np++].MoveTo(Icr3.mCon.x, Icr3.mCon.y); thePath[np++].MoveTo(Icr3.mAnc1.x, Icr3.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_BOTTOM,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_BOTTOM,border,qtwips, aIsOutline); } // left line ---------------------------------------------------------------- if(0==border.left) @@ -2782,7 +2790,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr4.mCon.x, Icr4.mCon.y); thePath[np++].MoveTo(Icr4.mAnc1.x, Icr4.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_LEFT,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_LEFT,border,qtwips, aIsOutline); } @@ -2792,7 +2800,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, */ void nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderingContext, - const nsStyleSpacing& aBorderStyle,nsIStyleContext* aStyleContext, + const nsStyleBorder* aBorderStyle,const nsStyleOutline* aOutlineStyle,nsIStyleContext* aStyleContext, PRUint8 aSide,nsMargin &aBorThick,nscoord aTwipsPerPixel, PRBool aIsOutline) { @@ -2803,11 +2811,12 @@ nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderin PRInt8 border_Style; PRInt16 thickness; + NS_ASSERTION((aIsOutline && aOutlineStyle) || (!aIsOutline && aBorderStyle), "null params not allowed"); // set the style information if (!aIsOutline) { - aBorderStyle.GetBorderColor(aSide,sideColor); + aBorderStyle->GetBorderColor(aSide,sideColor); } else { - aBorderStyle.GetOutlineColor(sideColor); + aOutlineStyle->GetOutlineColor(sideColor); } aRenderingContext.SetColor ( sideColor ); @@ -2838,16 +2847,15 @@ nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderin } else { if (!aIsOutline) { - border_Style = aBorderStyle.GetBorderStyle(aSide); + border_Style = aBorderStyle->GetBorderStyle(aSide); } else { - border_Style = aBorderStyle.GetOutlineStyle(); + border_Style = aOutlineStyle->GetOutlineStyle(); } switch (border_Style){ case NS_STYLE_BORDER_STYLE_OUTSET: case NS_STYLE_BORDER_STYLE_INSET: { const nsStyleColor* bgColor = nsStyleUtil::FindNonTransparentBackground(aStyleContext); - aBorderStyle.GetBorderColor(aSide,sideColor); aRenderingContext.SetColor ( MakeBevelColor (aSide, border_Style, bgColor->mBackgroundColor,sideColor, PR_TRUE)); } case NS_STYLE_BORDER_STYLE_DOTTED: @@ -2892,7 +2900,6 @@ nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderin case NS_STYLE_BORDER_STYLE_GROOVE: { const nsStyleColor* bgColor = nsStyleUtil::FindNonTransparentBackground(aStyleContext); - aBorderStyle.GetBorderColor(aSide,sideColor); aRenderingContext.SetColor ( MakeBevelColor (aSide, border_Style, bgColor->mBackgroundColor,sideColor, PR_TRUE)); polypath[0].x = NSToCoordRound(aPoints[0].x); diff --git a/mozilla/layout/base/nsCSSRendering.h b/mozilla/layout/base/nsCSSRendering.h index 91d473640b7..68c7a21e2d3 100644 --- a/mozilla/layout/base/nsCSSRendering.h +++ b/mozilla/layout/base/nsCSSRendering.h @@ -41,7 +41,7 @@ public: nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap = 0, @@ -61,7 +61,8 @@ public: nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, + const nsStyleOutline& aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap = 0); @@ -101,7 +102,7 @@ public: const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aStyle, + const nsStyleBorder& aBorder, nscoord aDX, nscoord aDY); @@ -118,7 +119,8 @@ public: static void DrawDashedSides(PRIntn startSide, nsIRenderingContext& aContext, const nsRect& aDirtyRect, - const nsStyleSpacing& aSpacing, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, PRBool aDoOutline, const nsRect& borderOutside, const nsRect& borderInside, @@ -147,7 +149,8 @@ protected: nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, PRInt16 aBorderRadius[4],nsRect* aGap = 0, @@ -155,7 +158,7 @@ protected: static void RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderingContext, - const nsStyleSpacing& aBorderStyle,nsIStyleContext* aStyleContext, + const nsStyleBorder* aBorderStyle,const nsStyleOutline* aOutlineStyle,nsIStyleContext* aStyleContext, PRUint8 aSide,nsMargin &aBorThick,nscoord aTwipsPerPixel, PRBool aIsOutline=PR_FALSE); @@ -165,7 +168,6 @@ protected: const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aStyle, nscoord aDX, nscoord aDY, PRInt16 aTheRadius[4]); diff --git a/mozilla/layout/base/nsStyleConsts.h b/mozilla/layout/base/nsStyleConsts.h index 3a29025a0be..eb355f6487c 100644 --- a/mozilla/layout/base/nsStyleConsts.h +++ b/mozilla/layout/base/nsStyleConsts.h @@ -195,13 +195,13 @@ #define NS_STYLE_BORDER_COLLAPSE 0 #define NS_STYLE_BORDER_SEPARATE 1 -// See nsStyleSpacing mBorder enum values +// See nsStyleBorder mBorder enum values #define NS_STYLE_BORDER_WIDTH_THIN 0 #define NS_STYLE_BORDER_WIDTH_MEDIUM 1 #define NS_STYLE_BORDER_WIDTH_THICK 2 // XXX chopping block #define NS_STYLE_BORDER_WIDTH_LENGTH_VALUE 3 -// See nsStyleSpacing mBorderStyle +// See nsStyleBorder mBorderStyle #define NS_STYLE_BORDER_STYLE_NONE 0 #define NS_STYLE_BORDER_STYLE_GROOVE 1 #define NS_STYLE_BORDER_STYLE_RIDGE 2 @@ -450,7 +450,7 @@ #define NS_STYLE_LIST_STYLE_POSITION_INSIDE 0 #define NS_STYLE_LIST_STYLE_POSITION_OUTSIDE 1 -// See nsStyleSpacing +// See nsStyleMargin #define NS_STYLE_MARGIN_SIZE_AUTO 0 // See nsStyleText diff --git a/mozilla/layout/base/public/nsHTMLReflowState.h b/mozilla/layout/base/public/nsHTMLReflowState.h index 87fed2cdbf6..bf4686d0ff9 100644 --- a/mozilla/layout/base/public/nsHTMLReflowState.h +++ b/mozilla/layout/base/public/nsHTMLReflowState.h @@ -33,7 +33,9 @@ class nsLineLayout; struct nsStyleDisplay; struct nsStylePosition; -struct nsStyleSpacing; +struct nsStyleBorder; +struct nsStyleMargin; +struct nsStylePadding; struct nsStyleText; struct nsHypotheticalBox; @@ -206,7 +208,9 @@ struct nsHTMLReflowState { // Cached pointers to the various style structs used during intialization const nsStyleDisplay* mStyleDisplay; const nsStylePosition* mStylePosition; - const nsStyleSpacing* mStyleSpacing; + const nsStyleBorder* mStyleBorder; + const nsStyleMargin* mStyleMargin; + const nsStylePadding* mStylePadding; const nsStyleText* mStyleText; // This value keeps track of how deeply nested a given reflow state diff --git a/mozilla/layout/base/public/nsIFrame.h b/mozilla/layout/base/public/nsIFrame.h index e7580093633..2e5609c9097 100644 --- a/mozilla/layout/base/public/nsIFrame.h +++ b/mozilla/layout/base/public/nsIFrame.h @@ -621,6 +621,10 @@ public: */ NS_IMETHOD GetStyleData(nsStyleStructID aSID, const nsStyleStruct*& aStyleStruct) const = 0; + // Fill a style struct with data + NS_IMETHOD GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const = 0; + // Utility function: more convenient than 2 calls to GetStyleData to get border and padding + NS_IMETHOD CalcBorderPadding(nsMargin& aBorderPadding) const = 0; /** * These methods are to access any additional style contexts that diff --git a/mozilla/layout/base/public/nsIStyleContext.h b/mozilla/layout/base/public/nsIStyleContext.h index 5100121dd96..6f9e15e479a 100644 --- a/mozilla/layout/base/public/nsIStyleContext.h +++ b/mozilla/layout/base/public/nsIStyleContext.h @@ -85,25 +85,47 @@ struct nsStyleColor : public nsStyleStruct { (NS_STYLE_BG_COLOR_TRANSPARENT | NS_STYLE_BG_IMAGE_NONE);} }; -struct nsStyleSpacing: public nsStyleStruct { - nsStyleSpacing(void); + +struct nsStyleMargin: public nsStyleStruct { + nsStyleMargin(void); nsStyleSides mMargin; // [reset] length, percent, auto, inherit - nsStyleSides mPadding; // [reset] length, percent, inherit - nsStyleSides mBorder; // [reset] length, enum (see nsStyleConsts.h) - - nsStyleSides mBorderRadius; // [reset] length, percent, inherit - nsStyleSides mOutlineRadius; // [reset] length, percent, inherit - // (top=topLeft, right=topRight, bottom=bottomRight, left=bottomLeft) - - nsStyleCoord mOutlineWidth; // [reset] length, enum (see nsStyleConsts.h) - - PRUint8 mFloatEdge; // [reset] see nsStyleConsts.h PRBool GetMargin(nsMargin& aMargin) const; + +// XXX this is a deprecated method + void CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const; + +protected: + PRPackedBool mHasCachedMargin; + nsMargin mCachedMargin; +}; + + +struct nsStylePadding: public nsStyleStruct { + nsStylePadding(void); + + nsStyleSides mPadding; // [reset] length, percent, inherit + PRBool GetPadding(nsMargin& aPadding) const; + +// XXX this is a deprecated method + void CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const; + +protected: + PRPackedBool mHasCachedPadding; + nsMargin mCachedPadding; +}; + + +struct nsStyleBorder: public nsStyleStruct { + nsStyleBorder(void); + + nsStyleSides mBorder; // [reset] length, enum (see nsStyleConsts.h) + nsStyleSides mBorderRadius; // [reset] length, percent, inherit + PRUint8 mFloatEdge; // [reset] see nsStyleConsts.h + PRBool GetBorder(nsMargin& aBorder) const; - PRBool GetBorderPadding(nsMargin& aBorderPadding) const; PRUint8 GetBorderStyle(PRUint8 aSide) const; void SetBorderStyle(PRUint8 aSide, PRUint8 aStyle); @@ -112,6 +134,37 @@ struct nsStyleSpacing: public nsStyleStruct { void SetBorderTransparent(PRUint8 aSide); void UnsetBorderColor(PRUint8 aSide); +// XXX these are deprecated methods + void CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const; + +protected: + PRPackedBool mHasCachedBorder; + nsMargin mCachedBorder; + + PRUint8 mBorderStyle[4]; // [reset] See nsStyleConsts.h + nscolor mBorderColor[4]; // [reset] +}; + + +struct nsStyleBorderPadding: public nsStyleStruct { + nsStyleBorderPadding(void); + + PRBool GetBorderPadding(nsMargin& aBorderPadding) const; + void SetBorderPadding(nsMargin aBorderPadding); +protected: + nsMargin mCachedBorderPadding; + PRPackedBool mHasCachedBorderPadding; +}; + + +struct nsStyleOutline: public nsStyleStruct { + nsStyleOutline(void); + + nsStyleSides mOutlineRadius; // [reset] length, percent, inherit + // (top=topLeft, right=topRight, bottom=bottomRight, left=bottomLeft) + + nsStyleCoord mOutlineWidth; // [reset] length, enum (see nsStyleConsts.h) + PRBool GetOutlineWidth(nscoord& aWidth) const; // PR_TRUE if pre-computed PRUint8 GetOutlineStyle(void) const; void SetOutlineStyle(PRUint8 aStyle); @@ -119,29 +172,16 @@ struct nsStyleSpacing: public nsStyleStruct { void SetOutlineColor(nscolor aColor); void SetOutlineInvert(void); -// XXX these are deprecated methods - void CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const; - void CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const; - void CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const; - void CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const; protected: - PRPackedBool mHasCachedMargin; - PRPackedBool mHasCachedPadding; - PRPackedBool mHasCachedBorder; - PRPackedBool mHasCachedOutline; - nsMargin mCachedMargin; - nsMargin mCachedPadding; - nsMargin mCachedBorder; - nsMargin mCachedBorderPadding; - nscoord mCachedOutlineWidth; + PRPackedBool mHasCachedOutline; + nscoord mCachedOutlineWidth; - PRUint8 mBorderStyle[4]; // [reset] See nsStyleConsts.h - nscolor mBorderColor[4]; // [reset] - PRUint8 mOutlineStyle; // [reset] See nsStyleConsts.h - nscolor mOutlineColor; // [reset] + PRUint8 mOutlineStyle; // [reset] See nsStyleConsts.h + nscolor mOutlineColor; // [reset] }; + struct nsStyleList : public nsStyleStruct { nsStyleList(void); ~nsStyleList(void); @@ -452,6 +492,9 @@ public: // call if you change style data after creation virtual void RecalcAutomaticData(nsIPresContext* aPresContext) = 0; + + // utility function: more convenient than 2 calls to GetStyleData to get border and padding + virtual void CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const = 0; }; // this is private to nsStyleSet, don't call it diff --git a/mozilla/layout/base/public/nsStyleConsts.h b/mozilla/layout/base/public/nsStyleConsts.h index 3a29025a0be..eb355f6487c 100644 --- a/mozilla/layout/base/public/nsStyleConsts.h +++ b/mozilla/layout/base/public/nsStyleConsts.h @@ -195,13 +195,13 @@ #define NS_STYLE_BORDER_COLLAPSE 0 #define NS_STYLE_BORDER_SEPARATE 1 -// See nsStyleSpacing mBorder enum values +// See nsStyleBorder mBorder enum values #define NS_STYLE_BORDER_WIDTH_THIN 0 #define NS_STYLE_BORDER_WIDTH_MEDIUM 1 #define NS_STYLE_BORDER_WIDTH_THICK 2 // XXX chopping block #define NS_STYLE_BORDER_WIDTH_LENGTH_VALUE 3 -// See nsStyleSpacing mBorderStyle +// See nsStyleBorder mBorderStyle #define NS_STYLE_BORDER_STYLE_NONE 0 #define NS_STYLE_BORDER_STYLE_GROOVE 1 #define NS_STYLE_BORDER_STYLE_RIDGE 2 @@ -450,7 +450,7 @@ #define NS_STYLE_LIST_STYLE_POSITION_INSIDE 0 #define NS_STYLE_LIST_STYLE_POSITION_OUTSIDE 1 -// See nsStyleSpacing +// See nsStyleMargin #define NS_STYLE_MARGIN_SIZE_AUTO 0 // See nsStyleText diff --git a/mozilla/layout/base/public/nsStyleStruct.h b/mozilla/layout/base/public/nsStyleStruct.h index fde2a5ed427..ee9ad77bc18 100644 --- a/mozilla/layout/base/public/nsStyleStruct.h +++ b/mozilla/layout/base/public/nsStyleStruct.h @@ -25,15 +25,22 @@ enum nsStyleStructID { eStyleStruct_Font = 1, eStyleStruct_Color = 2, - eStyleStruct_Spacing = 3, - eStyleStruct_List = 4, - eStyleStruct_Position = 5, - eStyleStruct_Text = 6, - eStyleStruct_Display = 7, - eStyleStruct_Table = 8, - eStyleStruct_Content = 9, - eStyleStruct_UserInterface = 10, - eStyleStruct_Print = 11 + eStyleStruct_List = 3, + eStyleStruct_Position = 4, + eStyleStruct_Text = 5, + eStyleStruct_Display = 6, + eStyleStruct_Table = 7, + eStyleStruct_Content = 8, + eStyleStruct_UserInterface = 9, + eStyleStruct_Print = 10, + eStyleStruct_Margin = 11, + eStyleStruct_Padding = 12, + eStyleStruct_Border = 13, + eStyleStruct_Outline = 14, + + eStyleStruct_Max = eStyleStruct_Outline, + + eStyleStruct_BorderPaddingShortcut = 15 // only for use in GetStyle() }; diff --git a/mozilla/layout/base/src/nsStyleContext.cpp b/mozilla/layout/base/src/nsStyleContext.cpp index f10e153777a..2c4f254771a 100644 --- a/mozilla/layout/base/src/nsStyleContext.cpp +++ b/mozilla/layout/base/src/nsStyleContext.cpp @@ -33,6 +33,7 @@ * 03/20/2000 IBM Corp. BiDi - ability to change the default direction of the browser * */ + #include "nsIStyleContext.h" #include "nsIMutableStyleContext.h" #include "nsStyleConsts.h" @@ -103,6 +104,26 @@ static nscoord CalcCoord(const nsStyleCoord& aCoord, const nscoord* aEnumTable, PRInt32 aNumEnums); +// XXX this is here to support deprecated calc spacing methods only +static nscoord kBorderWidths[3]; // contain the twips values for thin, medium and thick +static void InitBorderWidths(nsIPresContext* aPresContext) +{ + // XXX support kBorderWidhts until deprecated methods are removed + static PRBool kWidthsInitialized = PR_FALSE; + if (! kWidthsInitialized) { + kWidthsInitialized = PR_TRUE; + + float pixelsToTwips = 20.0f; + if (aPresContext) { + aPresContext->GetPixelsToTwips(&pixelsToTwips); + } + kBorderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); + kBorderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); + kBorderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); + } +} + + // EnsureBlockDisplay: // - if the display value (argument) is not a block-type // then we set it to a valid block display value @@ -220,6 +241,10 @@ PRUint32 StyleFontImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleColor // @@ -348,14 +373,13 @@ PRUint32 StyleColorImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } -// -------------------- -// nsStyleSpacing -// -// XXX this is here to support deprecated calc spacing methods only -static nscoord kBorderWidths[3]; -static PRBool kWidthsInitialized = PR_FALSE; +#ifdef XP_MAC +#pragma mark - +#endif -nsStyleSpacing::nsStyleSpacing(void) { } +#define BORDER_COLOR_DEFINED 0x80 +#define BORDER_COLOR_SPECIAL 0x40 +#define BORDER_STYLE_MASK 0x3F #define NS_SPACING_MARGIN 0 #define NS_SPACING_PADDING 1 @@ -379,21 +403,26 @@ static nscoord CalcSideFor(const nsIFrame* aFrame, const nsStyleCoord& aCoord, nsIStyleContext* parentContext; parentFrame->GetStyleContext(&parentContext); if (nsnull != parentContext) { - const nsStyleSpacing* parentSpacing = (const nsStyleSpacing*)parentContext->GetStyleData(eStyleStruct_Spacing); - nsMargin parentMargin; + nsMargin parentSide; switch (aSpacing) { - case NS_SPACING_MARGIN: parentSpacing->CalcMarginFor(parentFrame, parentMargin); + case NS_SPACING_MARGIN: + const nsStyleMargin* parentMargin = (const nsStyleMargin*)parentContext->GetStyleData(eStyleStruct_Margin); + parentMargin->CalcMarginFor(parentFrame, parentSide); break; - case NS_SPACING_PADDING: parentSpacing->CalcPaddingFor(parentFrame, parentMargin); + case NS_SPACING_PADDING: + const nsStylePadding* parentPadding = (const nsStylePadding*)parentContext->GetStyleData(eStyleStruct_Padding); + parentPadding->CalcPaddingFor(parentFrame, parentSide); break; - case NS_SPACING_BORDER: parentSpacing->CalcBorderFor(parentFrame, parentMargin); + case NS_SPACING_BORDER: + const nsStyleBorder* parentBorder = (const nsStyleBorder*)parentContext->GetStyleData(eStyleStruct_Border); + parentBorder->CalcBorderFor(parentFrame, parentSide); break; } switch (aSide) { - case NS_SIDE_LEFT: result = parentMargin.left; break; - case NS_SIDE_TOP: result = parentMargin.top; break; - case NS_SIDE_RIGHT: result = parentMargin.right; break; - case NS_SIDE_BOTTOM: result = parentMargin.bottom; break; + case NS_SIDE_LEFT: result = parentSide.left; break; + case NS_SIDE_TOP: result = parentSide.top; break; + case NS_SIDE_RIGHT: result = parentSide.right; break; + case NS_SIDE_BOTTOM: result = parentSide.bottom; break; } NS_RELEASE(parentContext); } @@ -466,248 +495,6 @@ static void CalcSidesFor(const nsIFrame* aFrame, const nsStyleSides& aSides, aEnumTable, aNumEnums); } -void nsStyleSpacing::CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const -{ - if (mHasCachedMargin) { - aMargin = mCachedMargin; - } else { - CalcSidesFor(aFrame, mMargin, NS_SPACING_MARGIN, nsnull, 0, aMargin); - } -} - -void nsStyleSpacing::CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const -{ - if (mHasCachedPadding) { - aPadding = mCachedPadding; - } else { - CalcSidesFor(aFrame, mPadding, NS_SPACING_PADDING, nsnull, 0, aPadding); - } -} - -void nsStyleSpacing::CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const -{ - if (mHasCachedBorder) { - aBorder = mCachedBorder; - } else { - CalcSidesFor(aFrame, mBorder, NS_SPACING_BORDER, kBorderWidths, 3, aBorder); - } -} - -void nsStyleSpacing::CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const -{ - if (mHasCachedPadding && mHasCachedBorder) { - aBorderPadding = mCachedBorderPadding; - } else { - nsMargin border; - CalcBorderFor(aFrame, border); - CalcPaddingFor(aFrame, aBorderPadding); - aBorderPadding += border; - } -} - -PRBool nsStyleSpacing::GetMargin(nsMargin& aMargin) const -{ - if (mHasCachedMargin) { - aMargin = mCachedMargin; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetPadding(nsMargin& aPadding) const -{ - if (mHasCachedPadding) { - aPadding = mCachedPadding; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetBorder(nsMargin& aBorder) const -{ - if (mHasCachedBorder) { - aBorder = mCachedBorder; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetBorderPadding(nsMargin& aBorderPadding) const -{ - if (mHasCachedPadding && mHasCachedBorder) { - aBorderPadding = mCachedBorderPadding; - return PR_TRUE; - } - return PR_FALSE; -} - -#define BORDER_COLOR_DEFINED 0x80 -#define BORDER_COLOR_SPECIAL 0x40 -#define BORDER_STYLE_MASK 0x3F - - -PRUint8 nsStyleSpacing::GetBorderStyle(PRUint8 aSide) const -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - return (mBorderStyle[aSide] & BORDER_STYLE_MASK); -} - -void nsStyleSpacing::SetBorderStyle(PRUint8 aSide, PRUint8 aStyle) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] &= ~BORDER_STYLE_MASK; - mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK); - -} - -PRBool nsStyleSpacing::GetBorderColor(PRUint8 aSide, nscolor& aColor) const -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0) { - aColor = mBorderColor[aSide]; - return PR_TRUE; - } - return PR_FALSE; -} - -void nsStyleSpacing::SetBorderColor(PRUint8 aSide, nscolor aColor) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderColor[aSide] = aColor; - mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL; - mBorderStyle[aSide] |= BORDER_COLOR_DEFINED; -} - -void nsStyleSpacing::SetBorderTransparent(PRUint8 aSide) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); -} - -void nsStyleSpacing::UnsetBorderColor(PRUint8 aSide) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] &= BORDER_STYLE_MASK; -} - -PRBool nsStyleSpacing::GetOutlineWidth(nscoord& aWidth) const -{ - if (mHasCachedOutline) { - aWidth = mCachedOutlineWidth; - return PR_TRUE; - } - return PR_FALSE; -} - -PRUint8 nsStyleSpacing::GetOutlineStyle(void) const -{ - return (mOutlineStyle & BORDER_STYLE_MASK); -} - -void nsStyleSpacing::SetOutlineStyle(PRUint8 aStyle) -{ - mOutlineStyle &= ~BORDER_STYLE_MASK; - mOutlineStyle |= (aStyle & BORDER_STYLE_MASK); -} - -PRBool nsStyleSpacing::GetOutlineColor(nscolor& aColor) const -{ - if ((mOutlineStyle & BORDER_COLOR_SPECIAL) == 0) { - aColor = mOutlineColor; - return PR_TRUE; - } - return PR_FALSE; -} - -void nsStyleSpacing::SetOutlineColor(nscolor aColor) -{ - mOutlineColor = aColor; - mOutlineStyle &= ~BORDER_COLOR_SPECIAL; - mOutlineStyle |= BORDER_COLOR_DEFINED; -} - -void nsStyleSpacing::SetOutlineInvert(void) -{ - mOutlineStyle |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); -} - - - -struct StyleSpacingImpl: public nsStyleSpacing { - StyleSpacingImpl(void) - : nsStyleSpacing() - {} - - void ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext); - void SetFrom(const nsStyleSpacing& aSource); - void CopyTo(nsStyleSpacing& aDest) const; - PRBool IsBorderSideVisible(PRUint8 aSide) const; - void RecalcData(nsIPresContext* aPresContext, nscolor color); - PRInt32 CalcDifference(const StyleSpacingImpl& aOther) const; - PRUint32 ComputeCRC32(PRUint32 aCrc) const; - -}; - -void StyleSpacingImpl::ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext) -{ - // XXX support kBorderWidhts until deprecated methods are removed - if (! kWidthsInitialized) { - float pixelsToTwips = 20.0f; - if (aPresContext) { - aPresContext->GetPixelsToTwips(&pixelsToTwips); - } - kBorderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); - kBorderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); - kBorderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); - kWidthsInitialized = PR_TRUE; - } - - - // spacing values not inherited - mMargin.Reset(); - mPadding.Reset(); - nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); - mBorder.SetLeft(medium); - mBorder.SetTop(medium); - mBorder.SetRight(medium); - mBorder.SetBottom(medium); - - mBorderStyle[0] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[1] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[2] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[3] = NS_STYLE_BORDER_STYLE_NONE; - - - mBorderColor[0] = NS_RGB(0, 0, 0); - mBorderColor[1] = NS_RGB(0, 0, 0); - mBorderColor[2] = NS_RGB(0, 0, 0); - mBorderColor[3] = NS_RGB(0, 0, 0); - - mBorderRadius.Reset(); - mOutlineRadius.Reset(); - - mOutlineWidth = medium; - mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE; - mOutlineColor = NS_RGB(0, 0, 0); - - mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT; - - mHasCachedMargin = PR_FALSE; - mHasCachedPadding = PR_FALSE; - mHasCachedBorder = PR_FALSE; - mHasCachedOutline = PR_FALSE; -} - -void StyleSpacingImpl::SetFrom(const nsStyleSpacing& aSource) -{ - nsCRT::memcpy((nsStyleSpacing*)this, &aSource, sizeof(nsStyleSpacing)); -} - -void StyleSpacingImpl::CopyTo(nsStyleSpacing& aDest) const -{ - nsCRT::memcpy(&aDest, (const nsStyleSpacing*)this, sizeof(nsStyleSpacing)); -} - static PRBool IsFixedData(const nsStyleSides& aSides, PRBool aEnumOK) { return PRBool(IsFixedUnit(aSides.GetLeftUnit(), aEnumOK) && @@ -740,24 +527,64 @@ static nscoord CalcCoord(const nsStyleCoord& aCoord, return 0; } -PRBool StyleSpacingImpl::IsBorderSideVisible(PRUint8 aSide) const + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleMargin::nsStyleMargin(void) { } + +PRBool nsStyleMargin::GetMargin(nsMargin& aMargin) const { - PRUint8 borderStyle = GetBorderStyle(aSide); - return ((borderStyle != NS_STYLE_BORDER_STYLE_NONE) - && (borderStyle != NS_STYLE_BORDER_STYLE_HIDDEN)); + if (mHasCachedMargin) { + aMargin = mCachedMargin; + return PR_TRUE; + } + return PR_FALSE; } -void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) +void nsStyleMargin::CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const { - nscoord borderWidths[3]; - float pixelsToTwips = 20.0f; - if (aPresContext) { - aPresContext->GetPixelsToTwips(&pixelsToTwips); + if (mHasCachedMargin) { + aMargin = mCachedMargin; + } else { + CalcSidesFor(aFrame, mMargin, NS_SPACING_MARGIN, nsnull, 0, aMargin); } - borderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); - borderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); - borderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); +} +struct StyleMarginImpl: public nsStyleMargin { + StyleMarginImpl(void) + : nsStyleMargin() + {} + + void ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleMargin& aSource); + void CopyTo(nsStyleMargin& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StyleMarginImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleMarginImpl::ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mMargin.Reset(); + mHasCachedMargin = PR_FALSE; +} + +void StyleMarginImpl::SetFrom(const nsStyleMargin& aSource) +{ + nsCRT::memcpy((nsStyleMargin*)this, &aSource, sizeof(nsStyleMargin)); +} + +void StyleMarginImpl::CopyTo(nsStyleMargin& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleMargin*)this, sizeof(nsStyleMargin)); +} + +void StyleMarginImpl::RecalcData(void) +{ if (IsFixedData(mMargin, PR_FALSE)) { nsStyleCoord coord; mCachedMargin.left = CalcCoord(mMargin.GetLeft(coord), nsnull, 0); @@ -770,7 +597,86 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) else { mHasCachedMargin = PR_FALSE; } +} +PRInt32 StyleMarginImpl::CalcDifference(const StyleMarginImpl& aOther) const +{ + if (mMargin == aOther.mMargin) { + return NS_STYLE_HINT_NONE; + } + return NS_STYLE_HINT_REFLOW; +} + +PRUint32 StyleMarginImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mMargin); + crc = AccumulateCRC(crc,(const char *)&mHasCachedMargin,sizeof(mHasCachedMargin)); + crc = StyleMarginCRC(crc,&mCachedMargin); +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStylePadding::nsStylePadding(void) { } + +PRBool nsStylePadding::GetPadding(nsMargin& aPadding) const +{ + if (mHasCachedPadding) { + aPadding = mCachedPadding; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStylePadding::CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const +{ + if (mHasCachedPadding) { + aPadding = mCachedPadding; + } else { + CalcSidesFor(aFrame, mPadding, NS_SPACING_PADDING, nsnull, 0, aPadding); + } +} + +struct StylePaddingImpl: public nsStylePadding { + StylePaddingImpl(void) + : nsStylePadding() + {} + + void ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStylePadding& aSource); + void CopyTo(nsStylePadding& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StylePaddingImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StylePaddingImpl::ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mPadding.Reset(); + mHasCachedPadding = PR_FALSE; +} + +void StylePaddingImpl::SetFrom(const nsStylePadding& aSource) +{ + nsCRT::memcpy((nsStylePadding*)this, &aSource, sizeof(nsStylePadding)); +} + +void StylePaddingImpl::CopyTo(nsStylePadding& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStylePadding*)this, sizeof(nsStylePadding)); +} + +void StylePaddingImpl::RecalcData(void) +{ if (IsFixedData(mPadding, PR_FALSE)) { nsStyleCoord coord; mCachedPadding.left = CalcCoord(mPadding.GetLeft(coord), nsnull, 0); @@ -783,7 +689,177 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) else { mHasCachedPadding = PR_FALSE; } +} +PRInt32 StylePaddingImpl::CalcDifference(const StylePaddingImpl& aOther) const +{ + if (mPadding == aOther.mPadding) { + return NS_STYLE_HINT_NONE; + } + return NS_STYLE_HINT_REFLOW; +} + +PRUint32 StylePaddingImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mPadding); + crc = AccumulateCRC(crc,(const char *)&mHasCachedPadding,sizeof(mHasCachedPadding)); + crc = StyleMarginCRC(crc,&mCachedPadding); +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleBorderPadding::nsStyleBorderPadding(void) { mHasCachedBorderPadding = PR_FALSE; } + +PRBool nsStyleBorderPadding::GetBorderPadding(nsMargin& aBorderPadding) const { + if (mHasCachedBorderPadding) { + aBorderPadding = mCachedBorderPadding; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleBorderPadding::SetBorderPadding(nsMargin aBorderPadding) { + mCachedBorderPadding = aBorderPadding; + mHasCachedBorderPadding = PR_TRUE; +} + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleBorder::nsStyleBorder(void) { } + +PRBool nsStyleBorder::GetBorder(nsMargin& aBorder) const +{ + if (mHasCachedBorder) { + aBorder = mCachedBorder; + return PR_TRUE; + } + return PR_FALSE; +} + +PRUint8 nsStyleBorder::GetBorderStyle(PRUint8 aSide) const +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + return (mBorderStyle[aSide] & BORDER_STYLE_MASK); +} + +void nsStyleBorder::SetBorderStyle(PRUint8 aSide, PRUint8 aStyle) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] &= ~BORDER_STYLE_MASK; + mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK); + +} + +PRBool nsStyleBorder::GetBorderColor(PRUint8 aSide, nscolor& aColor) const +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0) { + aColor = mBorderColor[aSide]; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleBorder::SetBorderColor(PRUint8 aSide, nscolor aColor) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderColor[aSide] = aColor; + mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL; + mBorderStyle[aSide] |= BORDER_COLOR_DEFINED; +} + +void nsStyleBorder::SetBorderTransparent(PRUint8 aSide) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); +} + +void nsStyleBorder::UnsetBorderColor(PRUint8 aSide) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] &= BORDER_STYLE_MASK; +} + +void nsStyleBorder::CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const +{ + if (mHasCachedBorder) { + aBorder = mCachedBorder; + } else { + CalcSidesFor(aFrame, mBorder, NS_SPACING_BORDER, kBorderWidths, 3, aBorder); + } +} + +struct StyleBorderImpl: public nsStyleBorder { + StyleBorderImpl(void) + : nsStyleBorder() + {} + + void ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleBorder& aSource); + void CopyTo(nsStyleBorder& aDest) const; + PRBool IsBorderSideVisible(PRUint8 aSide) const; + void RecalcData(nscolor color); + PRInt32 CalcDifference(const StyleBorderImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleBorderImpl::ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); + mBorder.SetLeft(medium); + mBorder.SetTop(medium); + mBorder.SetRight(medium); + mBorder.SetBottom(medium); + + mBorderStyle[0] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[1] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[2] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[3] = NS_STYLE_BORDER_STYLE_NONE; + + + mBorderColor[0] = NS_RGB(0, 0, 0); + mBorderColor[1] = NS_RGB(0, 0, 0); + mBorderColor[2] = NS_RGB(0, 0, 0); + mBorderColor[3] = NS_RGB(0, 0, 0); + + mBorderRadius.Reset(); + + mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT; + + mHasCachedBorder = PR_FALSE; +} + +void StyleBorderImpl::SetFrom(const nsStyleBorder& aSource) +{ + nsCRT::memcpy((nsStyleBorder*)this, &aSource, sizeof(nsStyleBorder)); +} + +void StyleBorderImpl::CopyTo(nsStyleBorder& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleBorder*)this, sizeof(nsStyleBorder)); +} + +PRBool StyleBorderImpl::IsBorderSideVisible(PRUint8 aSide) const +{ + PRUint8 borderStyle = GetBorderStyle(aSide); + return ((borderStyle != NS_STYLE_BORDER_STYLE_NONE) + && (borderStyle != NS_STYLE_BORDER_STYLE_HIDDEN)); +} + +void StyleBorderImpl::RecalcData(nscolor aColor) +{ if (((!IsBorderSideVisible(NS_SIDE_LEFT))|| IsFixedUnit(mBorder.GetLeftUnit(), PR_TRUE)) && ((!IsBorderSideVisible(NS_SIDE_TOP)) || @@ -797,25 +873,25 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) mCachedBorder.left = 0; } else { - mCachedBorder.left = CalcCoord(mBorder.GetLeft(coord), borderWidths, 3); + mCachedBorder.left = CalcCoord(mBorder.GetLeft(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_TOP)) { mCachedBorder.top = 0; } else { - mCachedBorder.top = CalcCoord(mBorder.GetTop(coord), borderWidths, 3); + mCachedBorder.top = CalcCoord(mBorder.GetTop(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_RIGHT)) { mCachedBorder.right = 0; } else { - mCachedBorder.right = CalcCoord(mBorder.GetRight(coord), borderWidths, 3); + mCachedBorder.right = CalcCoord(mBorder.GetRight(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_BOTTOM)) { mCachedBorder.bottom = 0; } else { - mCachedBorder.bottom = CalcCoord(mBorder.GetBottom(coord), borderWidths, 3); + mCachedBorder.bottom = CalcCoord(mBorder.GetBottom(coord), kBorderWidths, 3); } mHasCachedBorder = PR_TRUE; } @@ -823,11 +899,6 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) mHasCachedBorder = PR_FALSE; } - if (mHasCachedBorder && mHasCachedPadding) { - mCachedBorderPadding = mCachedPadding; - mCachedBorderPadding += mCachedBorder; - } - if ((mBorderStyle[NS_SIDE_TOP] & BORDER_COLOR_DEFINED) == 0) { mBorderColor[NS_SIDE_TOP] = aColor; } @@ -840,27 +911,11 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) if ((mBorderStyle[NS_SIDE_RIGHT] & BORDER_COLOR_DEFINED) == 0) { mBorderColor[NS_SIDE_RIGHT] = aColor; } - - if ((NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) || - IsFixedUnit(mOutlineWidth.GetUnit(), PR_TRUE)) { - if (NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) { - mCachedOutlineWidth = 0; - } - else { - mCachedOutlineWidth = CalcCoord(mOutlineWidth, borderWidths, 3); - } - mHasCachedOutline = PR_TRUE; - } - else { - mHasCachedOutline = PR_FALSE; - } } -PRInt32 StyleSpacingImpl::CalcDifference(const StyleSpacingImpl& aOther) const +PRInt32 StyleBorderImpl::CalcDifference(const StyleBorderImpl& aOther) const { - if ((mMargin == aOther.mMargin) && - (mPadding == aOther.mPadding) && - (mBorder == aOther.mBorder) && + if ((mBorder == aOther.mBorder) && (mFloatEdge == aOther.mFloatEdge)) { PRInt32 ix; for (ix = 0; ix < 4; ix++) { @@ -879,46 +934,158 @@ PRInt32 StyleSpacingImpl::CalcDifference(const StyleSpacingImpl& aOther) const if (mBorderRadius != aOther.mBorderRadius) { return NS_STYLE_HINT_VISUAL; } - if ((mOutlineWidth != aOther.mOutlineWidth) || - (mOutlineStyle != aOther.mOutlineStyle) || - (mOutlineColor != aOther.mOutlineColor) || - (mOutlineRadius != aOther.mOutlineRadius)) { - return NS_STYLE_HINT_VISUAL; // XXX: should be VISUAL: see bugs 9809 and 9816 - } return NS_STYLE_HINT_NONE; } return NS_STYLE_HINT_REFLOW; } -PRUint32 StyleSpacingImpl::ComputeCRC32(PRUint32 aCrc) const +PRUint32 StyleBorderImpl::ComputeCRC32(PRUint32 aCrc) const { PRUint32 crc = aCrc; #ifdef COMPUTE_STYLEDATA_CRC - crc = StyleSideCRC(crc,&mMargin); - crc = StyleSideCRC(crc,&mPadding); crc = StyleSideCRC(crc,&mBorder); crc = StyleSideCRC(crc,&mBorderRadius); - crc = StyleSideCRC(crc,&mOutlineRadius); - crc = StyleCoordCRC(crc,&mOutlineWidth); crc = AccumulateCRC(crc,(const char *)&mFloatEdge,sizeof(mFloatEdge)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedMargin,sizeof(mHasCachedMargin)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedPadding,sizeof(mHasCachedPadding)); crc = AccumulateCRC(crc,(const char *)&mHasCachedBorder,sizeof(mHasCachedBorder)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedOutline,sizeof(mHasCachedOutline)); - crc = StyleMarginCRC(crc,&mCachedMargin); - crc = StyleMarginCRC(crc,&mCachedPadding); crc = StyleMarginCRC(crc,&mCachedBorder); - crc = StyleMarginCRC(crc,&mCachedBorderPadding); - crc = AccumulateCRC(crc,(const char *)&mCachedOutlineWidth,sizeof(mCachedOutlineWidth)); crc = AccumulateCRC(crc,(const char *)mBorderStyle,sizeof(mBorderStyle)); // array of 4 elements crc = AccumulateCRC(crc,(const char *)mBorderColor,sizeof(mBorderColor)); // array ... +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleOutline::nsStyleOutline(void) { } + +PRBool nsStyleOutline::GetOutlineWidth(nscoord& aWidth) const +{ + if (mHasCachedOutline) { + aWidth = mCachedOutlineWidth; + return PR_TRUE; + } + return PR_FALSE; +} + +PRUint8 nsStyleOutline::GetOutlineStyle(void) const +{ + return (mOutlineStyle & BORDER_STYLE_MASK); +} + +void nsStyleOutline::SetOutlineStyle(PRUint8 aStyle) +{ + mOutlineStyle &= ~BORDER_STYLE_MASK; + mOutlineStyle |= (aStyle & BORDER_STYLE_MASK); +} + +PRBool nsStyleOutline::GetOutlineColor(nscolor& aColor) const +{ + if ((mOutlineStyle & BORDER_COLOR_SPECIAL) == 0) { + aColor = mOutlineColor; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleOutline::SetOutlineColor(nscolor aColor) +{ + mOutlineColor = aColor; + mOutlineStyle &= ~BORDER_COLOR_SPECIAL; + mOutlineStyle |= BORDER_COLOR_DEFINED; +} + +void nsStyleOutline::SetOutlineInvert(void) +{ + mOutlineStyle |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); +} + +struct StyleOutlineImpl: public nsStyleOutline { + StyleOutlineImpl(void) + : nsStyleOutline() + {} + + void ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleOutline& aSource); + void CopyTo(nsStyleOutline& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StyleOutlineImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleOutlineImpl::ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mOutlineRadius.Reset(); + + nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); + mOutlineWidth = medium; + mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE; + mOutlineColor = NS_RGB(0, 0, 0); + + mHasCachedOutline = PR_FALSE; +} + +void StyleOutlineImpl::SetFrom(const nsStyleOutline& aSource) +{ + nsCRT::memcpy((nsStyleOutline*)this, &aSource, sizeof(nsStyleOutline)); +} + +void StyleOutlineImpl::CopyTo(nsStyleOutline& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleOutline*)this, sizeof(nsStyleOutline)); +} + +void StyleOutlineImpl::RecalcData(void) +{ + if ((NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) || + IsFixedUnit(mOutlineWidth.GetUnit(), PR_TRUE)) { + if (NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) { + mCachedOutlineWidth = 0; + } + else { + mCachedOutlineWidth = CalcCoord(mOutlineWidth, kBorderWidths, 3); + } + mHasCachedOutline = PR_TRUE; + } + else { + mHasCachedOutline = PR_FALSE; + } +} + +PRInt32 StyleOutlineImpl::CalcDifference(const StyleOutlineImpl& aOther) const +{ + if ((mOutlineWidth != aOther.mOutlineWidth) || + (mOutlineStyle != aOther.mOutlineStyle) || + (mOutlineColor != aOther.mOutlineColor) || + (mOutlineRadius != aOther.mOutlineRadius)) { + return NS_STYLE_HINT_VISUAL; // XXX: should be VISUAL: see bugs 9809 and 9816 + } + return NS_STYLE_HINT_NONE; +} + +PRUint32 StyleOutlineImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mOutlineRadius); + crc = StyleCoordCRC(crc,&mOutlineWidth); + crc = AccumulateCRC(crc,(const char *)&mHasCachedOutline,sizeof(mHasCachedOutline)); + crc = AccumulateCRC(crc,(const char *)&mCachedOutlineWidth,sizeof(mCachedOutlineWidth)); crc = AccumulateCRC(crc,(const char *)&mOutlineStyle,sizeof(mOutlineStyle)); crc = AccumulateCRC(crc,(const char *)&mOutlineColor,sizeof(mOutlineColor)); #endif return crc; } +#ifdef XP_MAC +#pragma mark - +#endif // -------------------- // nsStyleList // @@ -988,6 +1155,10 @@ PRUint32 StyleListImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStylePosition // @@ -1073,6 +1244,10 @@ PRUint32 StylePositionImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleText // @@ -1172,6 +1347,10 @@ PRUint32 StyleTextImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleDisplay // @@ -1285,6 +1464,10 @@ PRUint32 StyleDisplayImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleTable // @@ -1393,6 +1576,9 @@ PRUint32 StyleTableImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStyleContent @@ -1754,6 +1940,9 @@ PRUint32 StyleContentImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStyleUserInterface @@ -1861,6 +2050,9 @@ PRUint32 StyleUserInterfaceImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStylePrint @@ -1953,6 +2145,9 @@ PRUint32 StylePrintImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //---------------------------------------------------------------------- @@ -1997,20 +2192,6 @@ void StyleColorImplLog::ResetFrom(const nsStyleColor* aParent, nsIPresContext* a mSetFromParent = (aParent != nsnull); } -// StyleSpacingImpl mSpacing; -struct StyleSpacingImplLog: public StyleSpacingImpl { - void ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext); - StyleSpacingImpl mInternalSpacing; - bool mSetFromParent; -}; - -void StyleSpacingImplLog::ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext) -{ - StyleSpacingImpl::ResetFrom(aParent, aPresContext); - CopyTo(mInternalSpacing); - mSetFromParent = (aParent != nsnull); -} - // StyleListImpl mList; struct StyleListImplLog: public StyleListImpl { void ResetFrom(const nsStyleList* aParent, nsIPresContext* aPresContext); @@ -2123,6 +2304,65 @@ void StylePrintImplLog::ResetFrom(const nsStylePrint* aParent, nsIPresContext* a mSetFromParent = (aParent != nsnull); } +// StyleMarginImpl mMargin; +struct StyleMarginImplLog: public StyleMarginImpl { + void ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext); + StyleMarginImpl mInternalMargin; + bool mSetFromParent; +}; + +void StyleMarginImplLog::ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext) +{ + StyleMarginImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalMargin); + mSetFromParent = (aParent != nsnull); +} + +// StylePaddingImpl mPadding; +struct StylePaddingImplLog: public StylePaddingImpl { + void ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext); + StylePaddingImpl mInternalPadding; + bool mSetFromParent; +}; + +void StylePaddingImplLog::ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext) +{ + StylePaddingImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalPadding); + mSetFromParent = (aParent != nsnull); +} + +// StyleBorderImpl mBorder; +struct StyleBorderImplLog: public StyleBorderImpl { + void ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext); + StyleBorderImpl mInternalBorder; + bool mSetFromParent; +}; + +void StyleBorderImplLog::ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext) +{ + StyleBorderImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalBorder); + mSetFromParent = (aParent != nsnull); +} + +// StyleOutlineImpl mOutline; +struct StyleOutlineImplLog: public StyleOutlineImpl { + void ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext); + StyleOutlineImpl mInternalOutline; + bool mSetFromParent; +}; + +void StyleOutlineImplLog::ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext) +{ + StyleOutlineImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalOutline); + mSetFromParent = (aParent != nsnull); +} + +#ifdef XP_MAC +#pragma mark - +#endif #endif // LOG_STYLE_STRUCTS //======================== @@ -2159,7 +2399,6 @@ private: // all data and methods private: only friends have access #ifdef LOG_STYLE_STRUCTS StyleFontImplLog mFont; StyleColorImplLog mColor; - StyleSpacingImplLog mSpacing; StyleListImplLog mList; StylePositionImplLog mPosition; StyleTextImplLog mText; @@ -2168,10 +2407,13 @@ private: // all data and methods private: only friends have access StyleContentImplLog mContent; StyleUserInterfaceImplLog mUserInterface; StylePrintImplLog mPrint; + StyleMarginImplLog mMargin; + StylePaddingImplLog mPadding; + StyleBorderImplLog mBorder; + StyleOutlineImplLog mOutline; #else StyleFontImpl mFont; StyleColorImpl mColor; - StyleSpacingImpl mSpacing; StyleListImpl mList; StylePositionImpl mPosition; StyleTextImpl mText; @@ -2180,6 +2422,10 @@ private: // all data and methods private: only friends have access StyleContentImpl mContent; StyleUserInterfaceImpl mUserInterface; StylePrintImpl mPrint; + StyleMarginImpl mMargin; + StylePaddingImpl mPadding; + StyleBorderImpl mBorder; + StyleOutlineImpl mOutline; #endif PRUint32 mRefCnt; @@ -2277,7 +2523,7 @@ static bool IsTimeToDumpStyleStructs() } static void LogStyleStructs(nsStyleContextData* aStyleContextData) { -#define max_structs eStyleStruct_Print +#define max_structs eStyleStruct_Max static unsigned long totalCount = 0; static unsigned long defaultStruct[max_structs]; @@ -2302,7 +2548,6 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) switch (index) { case eStyleStruct_Font: printf("eStyleStruct_Font "); sizeOfStruct = sizeof(StyleFontImpl); break; case eStyleStruct_Color: printf("eStyleStruct_Color "); sizeOfStruct = sizeof(StyleColorImpl); break; - case eStyleStruct_Spacing: printf("eStyleStruct_Spacing "); sizeOfStruct = sizeof(StyleSpacingImpl); break; case eStyleStruct_List: printf("eStyleStruct_List "); sizeOfStruct = sizeof(StyleListImpl); break; case eStyleStruct_Position: printf("eStyleStruct_Position "); sizeOfStruct = sizeof(StylePositionImpl); break; case eStyleStruct_Text: printf("eStyleStruct_Text "); sizeOfStruct = sizeof(StyleTextImpl); break; @@ -2311,6 +2556,10 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) case eStyleStruct_Content: printf("eStyleStruct_Content "); sizeOfStruct = sizeof(StyleContentImpl); break; case eStyleStruct_UserInterface: printf("eStyleStruct_UserInterface "); sizeOfStruct = sizeof(StyleUserInterfaceImpl); break; case eStyleStruct_Print: printf("eStyleStruct_Print "); sizeOfStruct = sizeof(StylePrintImpl); break; + case eStyleStruct_Margin: printf("eStyleStruct_Margin "); sizeOfStruct = sizeof(StyleMarginImpl); break; + case eStyleStruct_Padding: printf("eStyleStruct_Padding "); sizeOfStruct = sizeof(StylePaddingImpl); break; + case eStyleStruct_Border: printf("eStyleStruct_Border "); sizeOfStruct = sizeof(StyleBorderImpl); break; + case eStyleStruct_Outline: printf("eStyleStruct_Outline "); sizeOfStruct = sizeof(StyleOutlineImpl); break; } short percentDefault = (totalCount == 0 ? 0 : ((100 * defaultStruct[i]) / totalCount)); short percentFromParent = (defaultStruct[i] == 0 ? 0 : ((100 * setFromParent[i]) / defaultStruct[i])); @@ -2366,13 +2615,6 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) setFromParent[i]++; } break; - case eStyleStruct_Spacing: - if (aStyleContextData->mSpacing.CalcDifference(aStyleContextData->mSpacing.mInternalSpacing) == NS_STYLE_HINT_NONE) { - defaultStruct[i]++; - if (aStyleContextData->mSpacing.mSetFromParent) - setFromParent[i]++; - } - break; case eStyleStruct_List: if (aStyleContextData->mList.CalcDifference(aStyleContextData->mList.mInternalList) == NS_STYLE_HINT_NONE) { defaultStruct[i]++; @@ -2429,6 +2671,34 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) setFromParent[i]++; } break; + case eStyleStruct_Margin: + if (aStyleContextData->mMargin.CalcDifference(aStyleContextData->mMargin.mInternalMargin) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mMargin.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Padding: + if (aStyleContextData->mPadding.CalcDifference(aStyleContextData->mPadding.mInternalPadding) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mPadding.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Border: + if (aStyleContextData->mBorder.CalcDifference(aStyleContextData->mBorder.mInternalBorder) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mBorder.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Outline: + if (aStyleContextData->mOutline.CalcDifference(aStyleContextData->mOutline.mInternalOutline) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mOutline.mSetFromParent) + setFromParent[i]++; + } + break; } } @@ -2463,7 +2733,6 @@ PRUint32 nsStyleContextData::ComputeCRC32(PRUint32 aCrc) const // have each style struct compute its own CRC, propogating the previous value... crc = mFont.ComputeCRC32(crc); crc = mColor.ComputeCRC32(crc); - crc = mSpacing.ComputeCRC32(crc); crc = mList.ComputeCRC32(crc); crc = mPosition.ComputeCRC32(crc); crc = mText.ComputeCRC32(crc); @@ -2472,6 +2741,10 @@ PRUint32 nsStyleContextData::ComputeCRC32(PRUint32 aCrc) const crc = mContent.ComputeCRC32(crc); crc = mUserInterface.ComputeCRC32(crc); crc = mPrint.ComputeCRC32(crc); + crc = mMargin.ComputeCRC32(crc); + crc = mPadding.ComputeCRC32(crc); + crc = mBorder.ComputeCRC32(crc); + crc = mOutline.ComputeCRC32(crc); #else crc = 0; #endif @@ -2535,6 +2808,7 @@ public: virtual void ForceUnique(void); virtual void RecalcAutomaticData(nsIPresContext* aPresContext); + virtual void CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const; NS_IMETHOD CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PRBool aStopAtFirstDifference = PR_FALSE) const; #ifdef SHARE_STYLECONTEXTS @@ -2596,7 +2870,6 @@ protected: // the style data... StyleFontImpl mFont; StyleColorImpl mColor; - StyleSpacingImpl mSpacing; StyleListImpl mList; StylePositionImpl mPosition; StyleTextImpl mText; @@ -2605,6 +2878,10 @@ protected: StyleContentImpl mContent; StyleUserInterfaceImpl mUserInterface; StylePrintImpl mPrint; + StyleMarginImpl mMargin; + StylePaddingImpl mPadding; + StyleBorderImpl mBorder; + StyleOutlineImpl mOutline; #endif // #ifdef SHARE_STYLECONTEXTS @@ -2623,6 +2900,10 @@ static PRBool HashStyleRule(nsISupports* aRule, void* aData) return PR_TRUE; } +#ifdef XP_MAC +#pragma mark - +#endif + StyleContextImpl::StyleContextImpl(nsIStyleContext* aParent, nsIAtom* aPseudoTag, nsISupportsArray* aRules, @@ -2653,6 +2934,8 @@ StyleContextImpl::StyleContextImpl(nsIStyleContext* aParent, NS_IF_ADDREF(mPseudoTag); NS_IF_ADDREF(mRules); + InitBorderWidths(aPresContext); + mNextSibling = this; mPrevSibling = this; if (nsnull != mParent) { @@ -2916,7 +3199,9 @@ PRUint32 StyleContextImpl::HashValue(void) const //========================================================================================================= #ifdef DEBUG -//#define LOG_GET_STYLE_DATA_CALLS // define this to get stats on the calls to GetStyleData() //XXX pierre +// define this to get statistics on the number of calls +// to GetStyleData() and their depth in the Style tree. +//#define LOG_GET_STYLE_DATA_CALLS //XXX pierre #endif #ifdef LOG_GET_STYLE_DATA_CALLS @@ -2995,7 +3280,6 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon switch (i%max_structs + 1) { case eStyleStruct_Font: printf("eStyleStruct_Font "); break; case eStyleStruct_Color: printf("eStyleStruct_Color "); break; - case eStyleStruct_Spacing: printf("eStyleStruct_Spacing "); break; case eStyleStruct_List: printf("eStyleStruct_List "); break; case eStyleStruct_Position: printf("eStyleStruct_Position "); break; case eStyleStruct_Text: printf("eStyleStruct_Text "); break; @@ -3004,6 +3288,10 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon case eStyleStruct_Content: printf("eStyleStruct_Content "); break; case eStyleStruct_UserInterface: printf("eStyleStruct_UserInterface "); break; case eStyleStruct_Print: printf("eStyleStruct_Print "); break; + case eStyleStruct_Margin: printf("eStyleStruct_Margin "); break; + case eStyleStruct_Padding: printf("eStyleStruct_Padding "); break; + case eStyleStruct_Border: printf("eStyleStruct_Border "); break; + case eStyleStruct_Outline: printf("eStyleStruct_Outline "); break; } short percent = 100*calls[i]/totalCalls; short avdepth = calls[i] == 0 ? 0 : round(float(depth[i])/float(calls[i])); @@ -3076,7 +3364,6 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon #endif // LOG_GET_STYLE_DATA_CALLS //========================================================================================================= - const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) { #ifdef LOG_GET_STYLE_DATA_CALLS @@ -3092,9 +3379,6 @@ const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) case eStyleStruct_Color: result = & GETSCDATA(Color); break; - case eStyleStruct_Spacing: - result = & GETSCDATA(Spacing); - break; case eStyleStruct_List: result = & GETSCDATA(List); break; @@ -3119,6 +3403,18 @@ const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) case eStyleStruct_Print: result = & GETSCDATA(Print); break; + case eStyleStruct_Margin: + result = & GETSCDATA(Margin); + break; + case eStyleStruct_Padding: + result = & GETSCDATA(Padding); + break; + case eStyleStruct_Border: + result = & GETSCDATA(Border); + break; + case eStyleStruct_Outline: + result = & GETSCDATA(Outline); + break; default: NS_ERROR("Invalid style struct id"); break; @@ -3141,9 +3437,6 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) case eStyleStruct_Color: result = & GETSCDATA(Color); break; - case eStyleStruct_Spacing: - result = & GETSCDATA(Spacing); - break; case eStyleStruct_List: result = & GETSCDATA(List); break; @@ -3168,6 +3461,18 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) case eStyleStruct_Print: result = & GETSCDATA(Print); break; + case eStyleStruct_Margin: + result = & GETSCDATA(Margin); + break; + case eStyleStruct_Padding: + result = & GETSCDATA(Padding); + break; + case eStyleStruct_Border: + result = & GETSCDATA(Border); + break; + case eStyleStruct_Outline: + result = & GETSCDATA(Outline); + break; default: NS_ERROR("Invalid style struct id"); break; @@ -3181,6 +3486,18 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) return result; } +void StyleContextImpl::CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const +{ + nsMargin border, padding; + if (!GETSCDATA(Border).GetBorder(border)) { + GETSCDATA(Border).CalcBorderFor(aFrame, border); + } + if (!GETSCDATA(Padding).GetPadding(padding)) { + GETSCDATA(Padding).CalcPaddingFor(aFrame, padding); + } + aBorderPadding = border + padding; +} + NS_IMETHODIMP StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const { @@ -3192,9 +3509,6 @@ StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const case eStyleStruct_Color: GETSCDATA(Color).CopyTo((nsStyleColor&)aStruct); break; - case eStyleStruct_Spacing: - GETSCDATA(Spacing).CopyTo((nsStyleSpacing&)aStruct); - break; case eStyleStruct_List: GETSCDATA(List).CopyTo((nsStyleList&)aStruct); break; @@ -3219,6 +3533,27 @@ StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const case eStyleStruct_Print: GETSCDATA(Print).CopyTo((nsStylePrint&)aStruct); break; + case eStyleStruct_Margin: + GETSCDATA(Margin).CopyTo((nsStyleMargin&)aStruct); + break; + case eStyleStruct_Padding: + GETSCDATA(Padding).CopyTo((nsStylePadding&)aStruct); + break; + case eStyleStruct_Border: + GETSCDATA(Border).CopyTo((nsStyleBorder&)aStruct); + break; + case eStyleStruct_Outline: + GETSCDATA(Outline).CopyTo((nsStyleOutline&)aStruct); + break; + case eStyleStruct_BorderPaddingShortcut: + nsMargin border, padding; + if (GETSCDATA(Border).GetBorder(border)) { + if (GETSCDATA(Padding).GetPadding(padding)) { + border += padding; + ((nsStyleBorderPadding&)aStruct).SetBorderPadding(border); + } + } + break; default: NS_ERROR("Invalid style struct id"); result = NS_ERROR_INVALID_ARG; @@ -3238,9 +3573,6 @@ StyleContextImpl::SetStyle(nsStyleStructID aSID, const nsStyleStruct& aStruct) case eStyleStruct_Color: GETSCDATA(Color).SetFrom((const nsStyleColor&)aStruct); break; - case eStyleStruct_Spacing: - GETSCDATA(Spacing).SetFrom((const nsStyleSpacing&)aStruct); - break; case eStyleStruct_List: GETSCDATA(List).SetFrom((const nsStyleList&)aStruct); break; @@ -3265,6 +3597,18 @@ StyleContextImpl::SetStyle(nsStyleStructID aSID, const nsStyleStruct& aStruct) case eStyleStruct_Print: GETSCDATA(Print).SetFrom((const nsStylePrint&)aStruct); break; + case eStyleStruct_Margin: + GETSCDATA(Margin).SetFrom((const nsStyleMargin&)aStruct); + break; + case eStyleStruct_Padding: + GETSCDATA(Padding).SetFrom((const nsStylePadding&)aStruct); + break; + case eStyleStruct_Border: + GETSCDATA(Border).SetFrom((const nsStyleBorder&)aStruct); + break; + case eStyleStruct_Outline: + GETSCDATA(Outline).SetFrom((const nsStyleOutline&)aStruct); + break; default: NS_ERROR("Invalid style struct id"); result = NS_ERROR_INVALID_ARG; @@ -3313,7 +3657,6 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) if (nsnull != mParent) { GETSCDATA(Font).ResetFrom(&(mParent->GETSCDATA(Font)), aPresContext); GETSCDATA(Color).ResetFrom(&(mParent->GETSCDATA(Color)), aPresContext); - GETSCDATA(Spacing).ResetFrom(&(mParent->GETSCDATA(Spacing)), aPresContext); GETSCDATA(List).ResetFrom(&(mParent->GETSCDATA(List)), aPresContext); GETSCDATA(Position).ResetFrom(&(mParent->GETSCDATA(Position)), aPresContext); GETSCDATA(Text).ResetFrom(&(mParent->GETSCDATA(Text)), aPresContext); @@ -3322,11 +3665,14 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(&(mParent->GETSCDATA(Content)), aPresContext); GETSCDATA(UserInterface).ResetFrom(&(mParent->GETSCDATA(UserInterface)), aPresContext); GETSCDATA(Print).ResetFrom(&(mParent->GETSCDATA(Print)), aPresContext); + GETSCDATA(Margin).ResetFrom(&(mParent->GETSCDATA(Margin)), aPresContext); + GETSCDATA(Padding).ResetFrom(&(mParent->GETSCDATA(Padding)), aPresContext); + GETSCDATA(Border).ResetFrom(&(mParent->GETSCDATA(Border)), aPresContext); + GETSCDATA(Outline).ResetFrom(&(mParent->GETSCDATA(Outline)), aPresContext); } else { GETSCDATA(Font).ResetFrom(nsnull, aPresContext); GETSCDATA(Color).ResetFrom(nsnull, aPresContext); - GETSCDATA(Spacing).ResetFrom(nsnull, aPresContext); GETSCDATA(List).ResetFrom(nsnull, aPresContext); GETSCDATA(Position).ResetFrom(nsnull, aPresContext); GETSCDATA(Text).ResetFrom(nsnull, aPresContext); @@ -3335,6 +3681,10 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(nsnull, aPresContext); GETSCDATA(UserInterface).ResetFrom(nsnull, aPresContext); GETSCDATA(Print).ResetFrom(nsnull, aPresContext); + GETSCDATA(Margin).ResetFrom(nsnull, aPresContext); + GETSCDATA(Padding).ResetFrom(nsnull, aPresContext); + GETSCDATA(Border).ResetFrom(nsnull, aPresContext); + GETSCDATA(Outline).ResetFrom(nsnull, aPresContext); } PRUint32 cnt = 0; @@ -3404,7 +3754,6 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Font).ResetFrom(nsnull, aPresContext); } GETSCDATA(Color).ResetFrom(nsnull, aPresContext); - GETSCDATA(Spacing).ResetFrom(nsnull, aPresContext); GETSCDATA(List).ResetFrom(nsnull, aPresContext); GETSCDATA(Text).ResetFrom(nsnull, aPresContext); GETSCDATA(Position).ResetFrom(nsnull, aPresContext); @@ -3413,6 +3762,10 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(nsnull, aPresContext); GETSCDATA(UserInterface).ResetFrom(nsnull, aPresContext); GETSCDATA(Print).ResetFrom(nsnull, aPresContext); + GETSCDATA(Margin).ResetFrom(nsnull, aPresContext); + GETSCDATA(Padding).ResetFrom(nsnull, aPresContext); + GETSCDATA(Border).ResetFrom(nsnull, aPresContext); + GETSCDATA(Outline).ResetFrom(nsnull, aPresContext); GETSCDATA(Display).mVisible = visible; GETSCDATA(Display).mDirection = direction; GETSCDATA(Display).mLanguage = language; @@ -3497,7 +3850,10 @@ void StyleContextImpl::RecalcAutomaticData(nsIPresContext* aPresContext) if (NS_FAILED(EnsureStyleData(aPresContext))) { return /*NS_FAILURE*/; } - GETSCDATA(Spacing).RecalcData(aPresContext, GETSCDATA(Color).mColor); + GETSCDATA(Margin).RecalcData(); + GETSCDATA(Padding).RecalcData(); + GETSCDATA(Border).RecalcData(GETSCDATA(Color).mColor); + GETSCDATA(Outline).RecalcData(); } NS_IMETHODIMP @@ -3520,13 +3876,6 @@ StyleContextImpl::CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PR } } if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; - if (aHint < NS_STYLE_HINT_MAX) { - hint = GETSCDATA(Spacing).CalcDifference(other->GETSCDATA(Spacing)); - if (aHint < hint) { - aHint = hint; - } - } - if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; if (aHint < NS_STYLE_HINT_MAX) { hint = GETSCDATA(List).CalcDifference(other->GETSCDATA(List)); if (aHint < hint) { @@ -3582,6 +3931,34 @@ StyleContextImpl::CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PR aHint = hint; } } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Margin).CalcDifference(other->GETSCDATA(Margin)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Padding).CalcDifference(other->GETSCDATA(Padding)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Border).CalcDifference(other->GETSCDATA(Border)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Outline).CalcDifference(other->GETSCDATA(Outline)); + if (aHint < hint) { + aHint = hint; + } + } } return NS_OK; } @@ -3865,8 +4242,6 @@ void StyleContextImpl::SizeOf(nsISizeOfHandler *aSizeOfHandler, PRUint32 &aSize) totalSize += (long)sizeof(GETSCDATA(Font)); printf( " - StyleColorImpl: %ld\n", (long)sizeof(GETSCDATA(Color)) ); totalSize += (long)sizeof(GETSCDATA(Color)); - printf( " - StyleSpacingImpl: %ld\n", (long)sizeof(GETSCDATA(Spacing)) ); - totalSize += (long)sizeof(GETSCDATA(Spacing)); printf( " - StyleListImpl: %ld\n", (long)sizeof(GETSCDATA(List)) ); totalSize += (long)sizeof(GETSCDATA(List)); printf( " - StylePositionImpl: %ld\n", (long)sizeof(GETSCDATA(Position)) ); @@ -3883,6 +4258,14 @@ void StyleContextImpl::SizeOf(nsISizeOfHandler *aSizeOfHandler, PRUint32 &aSize) totalSize += (long)sizeof(GETSCDATA(UserInterface)); printf( " - StylePrintImpl: %ld\n", (long)sizeof(GETSCDATA(Print))); totalSize += (long)sizeof(GETSCDATA(Print)); + printf( " - StyleMarginImpl: %ld\n", (long)sizeof(GETSCDATA(Margin))); + totalSize += (long)sizeof(GETSCDATA(Margin)); + printf( " - StylePaddingImpl: %ld\n", (long)sizeof(GETSCDATA(Padding))); + totalSize += (long)sizeof(GETSCDATA(Padding)); + printf( " - StyleBorderImpl: %ld\n", (long)sizeof(GETSCDATA(Border))); + totalSize += (long)sizeof(GETSCDATA(Border)); + printf( " - StyleOutlineImpl: %ld\n", (long)sizeof(GETSCDATA(Outline))); + totalSize += (long)sizeof(GETSCDATA(Outline)); printf( " - Total: %ld\n", (long)totalSize); printf( "*************************************\n"); } @@ -3982,23 +4365,23 @@ void StyleContextImpl::DumpRegressionData(nsIPresContext* aPresContext, FILE* ou NS_ConvertUCS2toUTF8(GETSCDATA(Color).mCursorImage).get(), GETSCDATA(Color).mOpacity); - // SPACING + // SPACING (ie. margin, padding, border, outline) IndentBy(out,aIndent); fprintf(out, "\n"); // LIST diff --git a/mozilla/layout/forms/nsButtonFrameRenderer.cpp b/mozilla/layout/forms/nsButtonFrameRenderer.cpp index 789f676b8bf..2333c7b1a3f 100644 --- a/mozilla/layout/forms/nsButtonFrameRenderer.cpp +++ b/mozilla/layout/forms/nsButtonFrameRenderer.cpp @@ -144,10 +144,10 @@ nsButtonFrameRenderer::PaintOutlineAndFocusBorders(nsIPresContext* aPresContext, GetButtonOuterFocusRect(aRect, rect); - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mOuterFocusStyle ->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*)mOuterFocusStyle ->GetStyleData(eStyleStruct_Border); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, mFrame, - aDirtyRect, rect, *spacing, mOuterFocusStyle, 0); + aDirtyRect, rect, *border, mOuterFocusStyle, 0); } // ---------- paint the inner focus border ------------- @@ -155,10 +155,10 @@ nsButtonFrameRenderer::PaintOutlineAndFocusBorders(nsIPresContext* aPresContext, GetButtonInnerFocusRect(aRect, rect); - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Border); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, mFrame, - aDirtyRect, rect, *spacing, mInnerFocusStyle, 0); + aDirtyRect, rect, *border, mInnerFocusStyle, 0); } } @@ -186,8 +186,8 @@ nsButtonFrameRenderer::PaintBorderAndBackground(nsIPresContext* aPresContext, // get the styles - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)context->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)context->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)context->GetStyleData(eStyleStruct_Color); @@ -195,10 +195,10 @@ nsButtonFrameRenderer::PaintBorderAndBackground(nsIPresContext* aPresContext, // paint the border and background nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, mFrame, - aDirtyRect, buttonRect, *color, *spacing, 0, 0); + aDirtyRect, buttonRect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, mFrame, - aDirtyRect, buttonRect, *spacing, context, 0); + aDirtyRect, buttonRect, *border, context, 0); } @@ -247,9 +247,9 @@ nsButtonFrameRenderer::GetButtonOuterFocusBorderAndPadding() nsMargin focusBorderAndPadding(0,0,0,0); if (mOuterFocusStyle) { - // get the outer focus border and padding - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mOuterFocusStyle ->GetStyleData(eStyleStruct_Spacing); - if (!spacing->GetBorderPadding(focusBorderAndPadding)) { + nsStyleBorderPadding bPad; + mOuterFocusStyle->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (!bPad.GetBorderPadding(focusBorderAndPadding)) { NS_NOTYETIMPLEMENTED("percentage border"); } } @@ -263,12 +263,13 @@ nsButtonFrameRenderer::GetButtonBorderAndPadding() nsCOMPtr context; mFrame->GetStyleContext(getter_AddRefs(context)); - nsMargin borderAndPadding(0,0,0,0); - const nsStyleSpacing* spacing = (const nsStyleSpacing*)context ->GetStyleData(eStyleStruct_Spacing); - if (!spacing->GetBorderPadding(borderAndPadding)) { + nsMargin innerFocusBorderAndPadding(0,0,0,0); + nsStyleBorderPadding bPad; + context->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (!bPad.GetBorderPadding(innerFocusBorderAndPadding)) { NS_NOTYETIMPLEMENTED("percentage border"); } - return borderAndPadding; + return innerFocusBorderAndPadding; } /** @@ -281,8 +282,8 @@ nsButtonFrameRenderer::GetButtonInnerFocusMargin() if (mInnerFocusStyle) { // get the outer focus border and padding - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Spacing); - spacing->GetMargin(innerFocusMargin); + const nsStyleMargin* margin = (const nsStyleMargin*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Margin); + margin->GetMargin(innerFocusMargin); } return innerFocusMargin; @@ -295,8 +296,9 @@ nsButtonFrameRenderer::GetButtonInnerFocusBorderAndPadding() if (mInnerFocusStyle) { // get the outer focus border and padding - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Spacing); - if (!spacing->GetBorderPadding(innerFocusBorderAndPadding)) { + nsStyleBorderPadding bPad; + mInnerFocusStyle->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (!bPad.GetBorderPadding(innerFocusBorderAndPadding)) { NS_NOTYETIMPLEMENTED("percentage border"); } } diff --git a/mozilla/layout/forms/nsComboboxControlFrame.cpp b/mozilla/layout/forms/nsComboboxControlFrame.cpp index 4d2f99a8475..abf112bee84 100644 --- a/mozilla/layout/forms/nsComboboxControlFrame.cpp +++ b/mozilla/layout/forms/nsComboboxControlFrame.cpp @@ -830,11 +830,8 @@ nsComboboxControlFrame::ReflowItems(nsIPresContext* aPresContext, delete [] str; // get the borderPadding for the display area - const nsStyleSpacing* dspSpacing; - mDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - dspSpacing->CalcBorderPaddingFor(mDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); nscoord frmWidth = maxWidth+dspBorderPadding.left+dspBorderPadding.right+ aReflowState.mComputedBorderPadding.left + aReflowState.mComputedBorderPadding.right; @@ -886,11 +883,8 @@ nsComboboxControlFrame::ReflowCombobox(nsIPresContext * aPresContext, REFLOW_NOISY_MSG3("mCacheSize.height:%d - %d\n", PX(mCacheSize.height), PX((aBorderPadding.top + aBorderPadding.bottom))); // get the border and padding for the DisplayArea (block frame & textframe) - const nsStyleSpacing* dspSpacing; - aDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - dspSpacing->CalcBorderPaddingFor(aDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); // adjust the height if (mCacheSize.height == kSizeNotSet) { @@ -1154,11 +1148,8 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, bailOnWidth, bailOnHeight); if (bailOnWidth) { #ifdef DO_REFLOW_DEBUG // check or size - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - nsMargin borderPadding; - borderPadding.SizeTo(0, 0, 0, 0); - spacing->CalcBorderPaddingFor(this, borderPadding); + nsMargin borderPadding(0, 0, 0, 0); + CalcBorderPadding(borderPadding); UNCONSTRAINED_CHECK(); #endif REFLOW_DEBUG_MSG3("^** Done nsCCF DW: %d DH: %d\n\n", PX(aDesiredSize.width), PX(aDesiredSize.height)); @@ -1199,11 +1190,8 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, // get our border and padding, // XXX - should be the same mComputedBorderPadding? // maybe we should use that? - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - nsMargin borderPadding; - borderPadding.SizeTo(0, 0, 0, 0); - spacing->CalcBorderPaddingFor(this, borderPadding); + nsMargin borderPadding(0, 0, 0, 0); + CalcBorderPadding(borderPadding); // Get the current sizes of the combo box child frames mDisplayFrame->GetRect(displayRect); @@ -1480,18 +1468,12 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, } // Get the border and padding for the dropdown - const nsStyleSpacing* dropSpacing; - mDropdownFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dropSpacing); - nsMargin dropBorderPadding; - dropBorderPadding.SizeTo(0, 0, 0, 0); - dropSpacing->CalcBorderPaddingFor(mDropdownFrame, dropBorderPadding); + nsMargin dropBorderPadding(0, 0, 0, 0); + mDropdownFrame->CalcBorderPadding(dropBorderPadding); // get the borderPadding for the display area - const nsStyleSpacing* dspSpacing; - mDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - dspSpacing->CalcBorderPaddingFor(mDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); // Substract dropdown's borderPadding from the width of the dropdown rect // to get the size of the content area @@ -1571,12 +1553,8 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, } // get the borderPadding for the display area - const nsStyleSpacing* dspSpacing; - mDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - - dspSpacing->CalcBorderPaddingFor(mDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); if (NS_UNCONSTRAINEDSIZE == firstPassState.mComputedWidth) { mItemDisplayWidth = aDesiredSize.width - (dspBorderPadding.left + dspBorderPadding.right); diff --git a/mozilla/layout/forms/nsFieldSetFrame.cpp b/mozilla/layout/forms/nsFieldSetFrame.cpp index e60fb79664d..51f06b94582 100644 --- a/mozilla/layout/forms/nsFieldSetFrame.cpp +++ b/mozilla/layout/forms/nsFieldSetFrame.cpp @@ -163,11 +163,11 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* borderStyle = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); nsMargin border; - if (!spacing->GetBorder(border)) { + if (!borderStyle->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } @@ -181,7 +181,7 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, nsRect rect(0, yoff, mRect.width, mRect.height - yoff); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *borderStyle, 0, 0); if (mLegendFrame) { @@ -198,7 +198,7 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyle, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -212,7 +212,7 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyle, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -226,14 +226,14 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyle, mStyleContext, skipSides); aRenderingContext.PopState(clipState); } else { nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *spacing, mStyleContext, skipSides); + aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *borderStyle, mStyleContext, skipSides); } } } @@ -347,10 +347,10 @@ nsFieldSetFrame::Reflow(nsIPresContext* aPresContext, nsMargin legendMargin(0,0,0,0); // reflow the legend only if needed if (mLegendFrame) { - const nsStyleSpacing* legendSpacing; - mLegendFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) legendSpacing); - legendSpacing->GetMargin(legendMargin); + const nsStyleMargin* marginStyle; + mLegendFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) marginStyle); + marginStyle->GetMargin(legendMargin); if (reflowLegend) { nsHTMLReflowState legendReflowState(aPresContext, aReflowState, @@ -482,12 +482,12 @@ nsFieldSetFrame::Reflow(nsIPresContext* aPresContext, } else { // if we don't need to reflow just get the old size mContentFrame->GetRect(contentRect); - const nsStyleSpacing* spacing; - mContentFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); + const nsStyleMargin* marginStyle; + mContentFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) marginStyle); nsMargin m(0,0,0,0); - spacing->GetMargin(m); + marginStyle->GetMargin(m); contentRect.Inflate(m); } } diff --git a/mozilla/layout/forms/nsFormControlFrame.cpp b/mozilla/layout/forms/nsFormControlFrame.cpp index 00dd715ab88..9b207814899 100644 --- a/mozilla/layout/forms/nsFormControlFrame.cpp +++ b/mozilla/layout/forms/nsFormControlFrame.cpp @@ -925,9 +925,9 @@ nsresult nsFormControlFrame::PaintSpecialBorder(nsIPresContext* aPresContext, if (specialBorderStyle){ // paint the border - const nsStyleSpacing* spacing = (const nsStyleSpacing*)specialBorderStyle ->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*)specialBorderStyle ->GetStyleData(eStyleStruct_Border); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, aFrame, - aDirtyRect, aRect, *spacing, specialBorderStyle, 0); + aDirtyRect, aRect, *border, specialBorderStyle, 0); } } else { diff --git a/mozilla/layout/forms/nsGfxCheckboxControlFrame.cpp b/mozilla/layout/forms/nsGfxCheckboxControlFrame.cpp index a0034060f11..00985c130be 100644 --- a/mozilla/layout/forms/nsGfxCheckboxControlFrame.cpp +++ b/mozilla/layout/forms/nsGfxCheckboxControlFrame.cpp @@ -268,13 +268,10 @@ nsGfxCheckboxControlFrame::PaintCheckBox(nsIPresContext* aPresContext, float p2t; aPresContext->GetScaledPixelsToTwips(&p2t); - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + nsMargin borderPadding(0,0,0,0); + CalcBorderPadding(borderPadding); nsRect checkRect(0,0, mRect.width, mRect.height); - - nsMargin borderPadding; - spacing->CalcBorderPaddingFor(this, borderPadding); checkRect.Deflate(borderPadding); const nsStyleColor* color = (const nsStyleColor*) @@ -382,8 +379,8 @@ nsGfxCheckboxControlFrame::Paint(nsIPresContext* aPresContext, mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Color); if (myColor->mBackgroundImage.Length() > 0) { - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*) + mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Border); const nsStylePosition* myPosition = (const nsStylePosition*) mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Position); @@ -395,9 +392,9 @@ nsGfxCheckboxControlFrame::Paint(nsIPresContext* aPresContext, nsRect rect(x, y, width, height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *myColor, *mySpacing, 0, 0); + aDirtyRect, rect, *myColor, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mCheckButtonFaceStyle, 0); + aDirtyRect, rect, *myBorder, mCheckButtonFaceStyle, 0); doDefaultPainting = PR_FALSE; } } diff --git a/mozilla/layout/forms/nsGfxRadioControlFrame.cpp b/mozilla/layout/forms/nsGfxRadioControlFrame.cpp index 742b5c84c05..d7b593d4064 100644 --- a/mozilla/layout/forms/nsGfxRadioControlFrame.cpp +++ b/mozilla/layout/forms/nsGfxRadioControlFrame.cpp @@ -282,8 +282,8 @@ nsGfxRadioControlFrame::PaintRadioButton(nsIPresContext* aPresContext, if (nsnull != mRadioButtonFaceStyle) { const nsStyleColor* myColor = (const nsStyleColor*) mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*) + mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Border); const nsStylePosition* myPosition = (const nsStylePosition*) mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Position); @@ -300,9 +300,9 @@ nsGfxRadioControlFrame::PaintRadioButton(nsIPresContext* aPresContext, nsStyleColor tmpColor = *myColor; tmpColor.mBackgroundColor = myColor->mColor; nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, tmpColor, *mySpacing, 0, 0); + aDirtyRect, rect, tmpColor, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mRadioButtonFaceStyle, 0); + aDirtyRect, rect, *myBorder, mRadioButtonFaceStyle, 0); } } } diff --git a/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp b/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp index 5fadcbc33b1..070d83764f6 100644 --- a/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp +++ b/mozilla/layout/forms/nsHTMLButtonControlFrame.cpp @@ -492,11 +492,11 @@ nsHTMLButtonControlFrame::Paint(nsIPresContext* aPresContext, // but the real problem is the FirstChild (the AreaFrame) // isn't being constrained properly // Bug #17474 - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); + const nsStyleBorder* borderStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)borderStyle); nsMargin border; border.SizeTo(0, 0, 0, 0); - spacing->CalcBorderFor(this, border); + borderStyle->CalcBorderFor(this, border); nsRect rect; GetRect(rect); diff --git a/mozilla/layout/generic/nsAbsoluteContainingBlock.cpp b/mozilla/layout/generic/nsAbsoluteContainingBlock.cpp index c7b7640ebdc..96cf42a16b8 100644 --- a/mozilla/layout/generic/nsAbsoluteContainingBlock.cpp +++ b/mozilla/layout/generic/nsAbsoluteContainingBlock.cpp @@ -381,7 +381,7 @@ nsAbsoluteContainingBlock::ReflowAbsoluteFrame(nsIFrame* aDelegat nsMargin border; // Get the border values - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } diff --git a/mozilla/layout/generic/nsBlockFrame.cpp b/mozilla/layout/generic/nsBlockFrame.cpp index 6ba65c8bb8a..47de6fa7956 100644 --- a/mozilla/layout/generic/nsBlockFrame.cpp +++ b/mozilla/layout/generic/nsBlockFrame.cpp @@ -800,10 +800,10 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, if (mBand.GetFloaterCount()) { // Use the float-edge property to determine how the child block // will interact with the floater. - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - switch (spacing->mFloatEdge) { + const nsStyleBorder* borderStyle; + aFrame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&) borderStyle); + switch (borderStyle->mFloatEdge) { default: case NS_STYLE_FLOAT_EDGE_CONTENT: // content and only content does runaround of floaters // The child block will flow around the floater. Therefore @@ -819,11 +819,14 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, // The child block's border should be placed adjacent to, // but not overlap the floater(s). nsMargin m(0, 0, 0, 0); - spacing->GetMargin(m); // XXX percentage margins - if (NS_STYLE_FLOAT_EDGE_PADDING == spacing->mFloatEdge) { + const nsStyleMargin* styleMargin; + aFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) styleMargin); + styleMargin->GetMargin(m); // XXX percentage margins + if (NS_STYLE_FLOAT_EDGE_PADDING == borderStyle->mFloatEdge) { // Add in border too nsMargin b; - spacing->GetBorder(b); + borderStyle->GetBorder(b); m += b; } @@ -1487,7 +1490,7 @@ CalculateContainingBlock(const nsHTMLReflowState& aReflowState, // Containing block is relative to the padding edge nsMargin border; - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aContainingBlockWidth -= border.left + border.right; @@ -2018,15 +2021,32 @@ HaveAutoWidth(const nsHTMLReflowState& aReflowState) static PRBool IsPercentageAwareChild(const nsIFrame* aFrame) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (nsLineLayout::IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (nsLineLayout::IsPercentageUnitSides(&space->mMargin) - || nsLineLayout::IsPercentageUnitSides(&space->mPadding) - || nsLineLayout::IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -5929,12 +5949,9 @@ nsBlockReflowState::PlaceFloater(nsFloaterCache* aFloaterCache, // Get the type of floater const nsStyleDisplay* floaterDisplay; - const nsStyleSpacing* floaterSpacing; const nsStylePosition* floaterPosition; floater->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)floaterDisplay); - floater->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)floaterSpacing); floater->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&)floaterPosition); @@ -6254,18 +6271,20 @@ nsBlockFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); // Paint background, border and outline nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); } // If overflow is hidden then set the clip rect so that children don't diff --git a/mozilla/layout/generic/nsBlockReflowContext.cpp b/mozilla/layout/generic/nsBlockReflowContext.cpp index 5bdce97e42e..fe76a36e884 100644 --- a/mozilla/layout/generic/nsBlockReflowContext.cpp +++ b/mozilla/layout/generic/nsBlockReflowContext.cpp @@ -58,7 +58,9 @@ nsBlockReflowContext::nsBlockReflowContext(nsIPresContext* aPresContext, mComputeMaximumWidth(aComputeMaximumWidth), mBlockShouldInvalidateItself(PR_FALSE) { - mStyleSpacing = nsnull; + mStyleBorder = nsnull; + mStyleMargin = nsnull; + mStylePadding = nsnull; if (mComputeMaximumWidth) mMetrics.mFlags |= NS_REFLOW_CALC_MAX_WIDTH; } @@ -137,11 +139,11 @@ nsBlockReflowContext::AlignBlockHorizontally(nscoord aWidth, aAlign.mRightMargin = mMargin.right; // Get style unit associated with the left and right margins - nsStyleUnit leftUnit = mStyleSpacing->mMargin.GetLeftUnit(); + nsStyleUnit leftUnit = mStyleMargin->mMargin.GetLeftUnit(); if (eStyleUnit_Inherit == leftUnit) { leftUnit = GetRealMarginLeftUnit(); } - nsStyleUnit rightUnit = mStyleSpacing->mMargin.GetRightUnit(); + nsStyleUnit rightUnit = mStyleMargin->mMargin.GetRightUnit(); if (eStyleUnit_Inherit == rightUnit) { rightUnit = GetRealMarginRightUnit(); } @@ -335,25 +337,25 @@ nsBlockReflowContext::ReflowBlock(nsIFrame* aFrame, } static void -ComputeShrinkwrapMargins(const nsStyleSpacing* aStyleSpacing, nscoord aWidth, nsMargin& aMargin, nscoord& aXToUpdate) { +ComputeShrinkwrapMargins(const nsStyleMargin* aStyleMargin, nscoord aWidth, nsMargin& aMargin, nscoord& aXToUpdate) { nscoord boxWidth = aWidth; float leftPct = 0.0; float rightPct = 0.0; - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetLeftUnit()) { nsStyleCoord leftCoord; - aStyleSpacing->mMargin.GetLeft(leftCoord); + aStyleMargin->mMargin.GetLeft(leftCoord); leftPct = leftCoord.GetPercentValue(); } else { boxWidth += aMargin.left; } - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetRightUnit()) { nsStyleCoord rightCoord; - aStyleSpacing->mMargin.GetRight(rightCoord); + aStyleMargin->mMargin.GetRight(rightCoord); rightPct = rightCoord.GetPercentValue(); } else { @@ -379,11 +381,11 @@ ComputeShrinkwrapMargins(const nsStyleSpacing* aStyleSpacing, nscoord aWidth, ns if ((marginPct > 0.0) && (marginPct < 1.0)) { double shrinkWrapWidth = float(boxWidth) / (1.0 - marginPct); - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetLeftUnit()) { aMargin.left = NSToCoordFloor((float)(shrinkWrapWidth * leftPct)); aXToUpdate += aMargin.left; } - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetRightUnit()) { aMargin.right = NSToCoordFloor((float)(shrinkWrapWidth * rightPct)); } } @@ -442,7 +444,9 @@ nsBlockReflowContext::DoReflowBlock(nsHTMLReflowState &aReflowState, // from 10.3.3 to determine what to apply. At this point in the // reflow auto left/right margins will have a zero value. mMargin = aReflowState.mComputedMargin; - mStyleSpacing = aReflowState.mStyleSpacing; + mStyleBorder = aReflowState.mStyleBorder; + mStyleMargin = aReflowState.mStyleMargin; + mStylePadding = aReflowState.mStylePadding; nscoord x; nscoord y = aSpace.y + topMargin; @@ -658,7 +662,7 @@ nsBlockReflowContext::DoReflowBlock(nsHTMLReflowState &aReflowState, // based margins. If so, we can calculate them now that we know the shrink // wrap width if (NS_SHRINKWRAPWIDTH == aReflowState.mComputedWidth) { - ComputeShrinkwrapMargins(aReflowState.mStyleSpacing, mMetrics.width, mMargin, mX); + ComputeShrinkwrapMargins(aReflowState.mStyleMargin, mMetrics.width, mMargin, mX); } return rv; @@ -771,15 +775,15 @@ nsBlockReflowContext::PlaceBlock(PRBool aForceFit, if (NS_SHRINKWRAPWIDTH == mComputedWidth) { nscoord dummyXOffset; // Base the margins on the max-element size - ComputeShrinkwrapMargins(mStyleSpacing, m->width, maxElemMargin, dummyXOffset); + ComputeShrinkwrapMargins(mStyleMargin, m->width, maxElemMargin, dummyXOffset); } // Do not allow auto margins to impact the max-element size // since they are springy and don't really count! - if (eStyleUnit_Auto != mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Auto != mStyleMargin->mMargin.GetLeftUnit()) { m->width += maxElemMargin.left; } - if (eStyleUnit_Auto != mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Auto != mStyleMargin->mMargin.GetRightUnit()) { m->width += maxElemMargin.right; } @@ -817,9 +821,9 @@ nsBlockReflowContext::GetRealMarginLeftUnit() NS_RELEASE(sc); sc = psc; if (nsnull != sc) { - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - sc->GetStyleData(eStyleStruct_Spacing); - unit = spacing->mMargin.GetLeftUnit(); + const nsStyleMargin* margin = (const nsStyleMargin*) + sc->GetStyleData(eStyleStruct_Margin); + unit = margin->mMargin.GetLeftUnit(); } } NS_IF_RELEASE(sc); @@ -842,9 +846,9 @@ nsBlockReflowContext::GetRealMarginRightUnit() NS_RELEASE(sc); sc = psc; if (nsnull != sc) { - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - sc->GetStyleData(eStyleStruct_Spacing); - unit = spacing->mMargin.GetRightUnit(); + const nsStyleMargin* margin = (const nsStyleMargin*) + sc->GetStyleData(eStyleStruct_Margin); + unit = margin->mMargin.GetRightUnit(); } } NS_IF_RELEASE(sc); diff --git a/mozilla/layout/generic/nsBlockReflowContext.h b/mozilla/layout/generic/nsBlockReflowContext.h index 308abd13c38..65139793669 100644 --- a/mozilla/layout/generic/nsBlockReflowContext.h +++ b/mozilla/layout/generic/nsBlockReflowContext.h @@ -29,7 +29,6 @@ class nsIFrame; class nsIPresContext; class nsLineLayout; struct nsStylePosition; -struct nsStyleSpacing; struct nsBlockHorizontalAlign; /** @@ -137,7 +136,9 @@ protected: nsIFrame* mNextRCFrame; // Spacing style for the frame we are reflowing; only valid after reflow - const nsStyleSpacing* mStyleSpacing; + const nsStyleBorder* mStyleBorder; + const nsStyleMargin* mStyleMargin; + const nsStylePadding* mStylePadding; nscoord mComputedWidth; // copy of reflowstate's computedWidth nsMargin mMargin; diff --git a/mozilla/layout/generic/nsBlockReflowState.cpp b/mozilla/layout/generic/nsBlockReflowState.cpp index 6ba65c8bb8a..47de6fa7956 100644 --- a/mozilla/layout/generic/nsBlockReflowState.cpp +++ b/mozilla/layout/generic/nsBlockReflowState.cpp @@ -800,10 +800,10 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, if (mBand.GetFloaterCount()) { // Use the float-edge property to determine how the child block // will interact with the floater. - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - switch (spacing->mFloatEdge) { + const nsStyleBorder* borderStyle; + aFrame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&) borderStyle); + switch (borderStyle->mFloatEdge) { default: case NS_STYLE_FLOAT_EDGE_CONTENT: // content and only content does runaround of floaters // The child block will flow around the floater. Therefore @@ -819,11 +819,14 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, // The child block's border should be placed adjacent to, // but not overlap the floater(s). nsMargin m(0, 0, 0, 0); - spacing->GetMargin(m); // XXX percentage margins - if (NS_STYLE_FLOAT_EDGE_PADDING == spacing->mFloatEdge) { + const nsStyleMargin* styleMargin; + aFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) styleMargin); + styleMargin->GetMargin(m); // XXX percentage margins + if (NS_STYLE_FLOAT_EDGE_PADDING == borderStyle->mFloatEdge) { // Add in border too nsMargin b; - spacing->GetBorder(b); + borderStyle->GetBorder(b); m += b; } @@ -1487,7 +1490,7 @@ CalculateContainingBlock(const nsHTMLReflowState& aReflowState, // Containing block is relative to the padding edge nsMargin border; - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aContainingBlockWidth -= border.left + border.right; @@ -2018,15 +2021,32 @@ HaveAutoWidth(const nsHTMLReflowState& aReflowState) static PRBool IsPercentageAwareChild(const nsIFrame* aFrame) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (nsLineLayout::IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (nsLineLayout::IsPercentageUnitSides(&space->mMargin) - || nsLineLayout::IsPercentageUnitSides(&space->mPadding) - || nsLineLayout::IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -5929,12 +5949,9 @@ nsBlockReflowState::PlaceFloater(nsFloaterCache* aFloaterCache, // Get the type of floater const nsStyleDisplay* floaterDisplay; - const nsStyleSpacing* floaterSpacing; const nsStylePosition* floaterPosition; floater->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)floaterDisplay); - floater->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)floaterSpacing); floater->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&)floaterPosition); @@ -6254,18 +6271,20 @@ nsBlockFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); // Paint background, border and outline nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); } // If overflow is hidden then set the clip rect so that children don't diff --git a/mozilla/layout/generic/nsBlockReflowState.h b/mozilla/layout/generic/nsBlockReflowState.h index 6ba65c8bb8a..47de6fa7956 100644 --- a/mozilla/layout/generic/nsBlockReflowState.h +++ b/mozilla/layout/generic/nsBlockReflowState.h @@ -800,10 +800,10 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, if (mBand.GetFloaterCount()) { // Use the float-edge property to determine how the child block // will interact with the floater. - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - switch (spacing->mFloatEdge) { + const nsStyleBorder* borderStyle; + aFrame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&) borderStyle); + switch (borderStyle->mFloatEdge) { default: case NS_STYLE_FLOAT_EDGE_CONTENT: // content and only content does runaround of floaters // The child block will flow around the floater. Therefore @@ -819,11 +819,14 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, // The child block's border should be placed adjacent to, // but not overlap the floater(s). nsMargin m(0, 0, 0, 0); - spacing->GetMargin(m); // XXX percentage margins - if (NS_STYLE_FLOAT_EDGE_PADDING == spacing->mFloatEdge) { + const nsStyleMargin* styleMargin; + aFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) styleMargin); + styleMargin->GetMargin(m); // XXX percentage margins + if (NS_STYLE_FLOAT_EDGE_PADDING == borderStyle->mFloatEdge) { // Add in border too nsMargin b; - spacing->GetBorder(b); + borderStyle->GetBorder(b); m += b; } @@ -1487,7 +1490,7 @@ CalculateContainingBlock(const nsHTMLReflowState& aReflowState, // Containing block is relative to the padding edge nsMargin border; - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aContainingBlockWidth -= border.left + border.right; @@ -2018,15 +2021,32 @@ HaveAutoWidth(const nsHTMLReflowState& aReflowState) static PRBool IsPercentageAwareChild(const nsIFrame* aFrame) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (nsLineLayout::IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (nsLineLayout::IsPercentageUnitSides(&space->mMargin) - || nsLineLayout::IsPercentageUnitSides(&space->mPadding) - || nsLineLayout::IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -5929,12 +5949,9 @@ nsBlockReflowState::PlaceFloater(nsFloaterCache* aFloaterCache, // Get the type of floater const nsStyleDisplay* floaterDisplay; - const nsStyleSpacing* floaterSpacing; const nsStylePosition* floaterPosition; floater->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)floaterDisplay); - floater->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)floaterSpacing); floater->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&)floaterPosition); @@ -6254,18 +6271,20 @@ nsBlockFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); // Paint background, border and outline nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); } // If overflow is hidden then set the clip rect so that children don't diff --git a/mozilla/layout/generic/nsContainerFrame.cpp b/mozilla/layout/generic/nsContainerFrame.cpp index 6a9ec3d0054..f14b4ef8cbf 100644 --- a/mozilla/layout/generic/nsContainerFrame.cpp +++ b/mozilla/layout/generic/nsContainerFrame.cpp @@ -599,18 +599,20 @@ nsContainerFrame::SyncFrameViewAfterReflow(nsIPresContext* aPresContext, } if (hasOverflowClip) { - const nsStyleSpacing* spacing; + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; nsMargin border, padding; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + aFrame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderStyle); + aFrame->GetStyleData(eStyleStruct_Padding, (const nsStyleStruct*&)paddingStyle); // XXX We don't support the 'overflow-clip' property yet so just use the // content area (which is the default value) as the clip shape overflowClipRect.SetRect(0, 0, frameSize.width, frameSize.height); - spacing->GetBorder(border); + borderStyle->GetBorder(border); overflowClipRect.Deflate(border); // XXX We need to handle percentage padding - if (spacing->GetPadding(padding)) { + if (paddingStyle->GetPadding(padding)) { overflowClipRect.Deflate(padding); } } diff --git a/mozilla/layout/generic/nsFrame.cpp b/mozilla/layout/generic/nsFrame.cpp index 96a79aba6ba..eaf4fc5eebe 100644 --- a/mozilla/layout/generic/nsFrame.cpp +++ b/mozilla/layout/generic/nsFrame.cpp @@ -493,6 +493,23 @@ NS_IMETHODIMP nsFrame::GetStyleData(nsStyleStructID aSID, const nsStyleStruct*& return NS_OK; } +NS_IMETHODIMP nsFrame::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const { + NS_ASSERTION(mStyleContext!=nsnull,"null style context"); + if (mStyleContext) { + return mStyleContext->GetStyle(aSID, aStruct); + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP nsFrame::CalcBorderPadding(nsMargin& aBorderPadding) const { + NS_ASSERTION(mStyleContext!=nsnull,"null style context"); + if (mStyleContext) { + mStyleContext->CalcBorderPaddingFor(this, aBorderPadding); + return NS_OK; + } + return NS_ERROR_FAILURE; +} + NS_IMETHODIMP nsFrame::GetAdditionalStyleContext(PRInt32 aIndex, nsIStyleContext** aStyleContext) const @@ -624,8 +641,10 @@ nsFrame::SetOverflowClipRect(nsIRenderingContext& aRenderingContext) // 'overflow-clip' only applies to block-level elements and replaced // elements that have 'overflow' set to 'hidden', and it is relative // to the content area and applies to content only (not border or background) - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderStyle); + GetStyleData(eStyleStruct_Padding, (const nsStyleStruct*&)paddingStyle); // Start with the 'auto' values and then factor in user specified values nsRect clipRect(0, 0, mRect.width, mRect.height); @@ -634,10 +653,10 @@ nsFrame::SetOverflowClipRect(nsIRenderingContext& aRenderingContext) // content area (which is the default value) as the clip shape nsMargin border, padding; - spacing->GetBorder(border); + borderStyle->GetBorder(border); clipRect.Deflate(border); // XXX We need to handle percentage padding - if (spacing->GetPadding(padding)) { + if (paddingStyle->GetPadding(padding)) { clipRect.Deflate(padding); } @@ -2073,10 +2092,10 @@ nsFrame::Invalidate(nsIPresContext* aPresContext, // Checks to see if the damaged rect should be infalted // to include the outline - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + const nsStyleOutline* outline; + GetStyleData(eStyleStruct_Outline, (const nsStyleStruct*&)outline); nscoord width; - spacing->GetOutlineWidth(width); + outline->GetOutlineWidth(width); if (width > 0) { damageRect.Inflate(width, width); } diff --git a/mozilla/layout/generic/nsFrame.h b/mozilla/layout/generic/nsFrame.h index b0ce1c522b2..582c32340d0 100644 --- a/mozilla/layout/generic/nsFrame.h +++ b/mozilla/layout/generic/nsFrame.h @@ -173,6 +173,8 @@ public: nsIStyleContext* aContext); NS_IMETHOD GetStyleData(nsStyleStructID aSID, const nsStyleStruct*& aStyleStruct) const; + NS_IMETHOD GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const; + NS_IMETHOD CalcBorderPadding(nsMargin& aBorderPadding) const; NS_IMETHOD GetAdditionalStyleContext(PRInt32 aIndex, nsIStyleContext** aStyleContext) const; NS_IMETHOD SetAdditionalStyleContext(PRInt32 aIndex, diff --git a/mozilla/layout/generic/nsHTMLContainerFrame.cpp b/mozilla/layout/generic/nsHTMLContainerFrame.cpp index 1d7c6a12590..d2ffcad073a 100644 --- a/mozilla/layout/generic/nsHTMLContainerFrame.cpp +++ b/mozilla/layout/generic/nsHTMLContainerFrame.cpp @@ -73,16 +73,18 @@ nsHTMLContainerFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); // The sole purpose of this is to trigger display // of the selection window for Named Anchors, diff --git a/mozilla/layout/generic/nsHTMLFrame.cpp b/mozilla/layout/generic/nsHTMLFrame.cpp index 5332867867f..12bc4d0cf8e 100644 --- a/mozilla/layout/generic/nsHTMLFrame.cpp +++ b/mozilla/layout/generic/nsHTMLFrame.cpp @@ -304,7 +304,7 @@ CanvasFrame::Reflow(nsIPresContext* aPresContext, nsMargin border; nsFrameState kidState; - if (!kidReflowState.mStyleSpacing->GetBorder(border)) { + if (!kidReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } kidFrame->GetFrameState(&kidState); diff --git a/mozilla/layout/generic/nsHTMLReflowState.cpp b/mozilla/layout/generic/nsHTMLReflowState.cpp index cd61f6ae513..14c16e20834 100644 --- a/mozilla/layout/generic/nsHTMLReflowState.cpp +++ b/mozilla/layout/generic/nsHTMLReflowState.cpp @@ -179,8 +179,12 @@ nsHTMLReflowState::Init(nsIPresContext* aPresContext, (const nsStyleStruct*&)mStylePosition); frame->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)mStyleDisplay); - frame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)mStyleSpacing); + frame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&)mStyleBorder); + frame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&)mStyleMargin); + frame->GetStyleData(eStyleStruct_Padding, + (const nsStyleStruct*&)mStylePadding); frame->GetStyleData(eStyleStruct_Text, (const nsStyleStruct*&)mStyleText); mFrameType = DetermineFrameType(frame, mStylePosition, mStyleDisplay); @@ -475,10 +479,10 @@ GetNearestContainingBlock(nsIFrame* aFrame, nsMargin& aContentArea) // Subtract off for border and padding. If it can't be computed because // it's percentage based (for example) then just ignore it - nsStyleSpacing* spacing; - nsMargin borderPadding; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing->GetBorderPadding(borderPadding)) { + nsStyleBorderPadding bPad; + nsMargin borderPadding; + aFrame->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (bPad.GetBorderPadding(borderPadding)) { aContentArea.left += borderPadding.left; aContentArea.top += borderPadding.top; aContentArea.right -= borderPadding.right; @@ -534,55 +538,55 @@ nsHTMLReflowState::CalculateHorizBorderPaddingMargin(nscoord aContainingBlockWid nsMargin border, padding, margin; // Get the border - if (!mStyleSpacing->GetBorder(border)) { + if (!mStyleBorder->GetBorder(border)) { // CSS2 has no percentage borders border.SizeTo(0, 0, 0, 0); } // See if the style system can provide us the padding directly - if (!mStyleSpacing->GetPadding(padding)) { + if (!mStylePadding->GetPadding(padding)) { nsStyleCoord left, right; // We have to compute the left and right values - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetLeftUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetLeftUnit()) { padding.left = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetLeftUnit(), - mStyleSpacing->mPadding.GetLeft(left), + mStylePadding->mPadding.GetLeftUnit(), + mStylePadding->mPadding.GetLeft(left), padding.left); } - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetRightUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetRightUnit()) { padding.right = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetRightUnit(), - mStyleSpacing->mPadding.GetRight(right), + mStylePadding->mPadding.GetRightUnit(), + mStylePadding->mPadding.GetRight(right), padding.right); } } // See if the style system can provide us the margin directly - if (!mStyleSpacing->GetMargin(margin)) { + if (!mStyleMargin->GetMargin(margin)) { nsStyleCoord left, right; // We have to compute the left and right values - if ((eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit()) || - (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetLeftUnit())) { + if ((eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit()) || + (eStyleUnit_Inherit == mStyleMargin->mMargin.GetLeftUnit())) { margin.left = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetLeftUnit(), - mStyleSpacing->mMargin.GetLeft(left), + mStyleMargin->mMargin.GetLeftUnit(), + mStyleMargin->mMargin.GetLeft(left), margin.left); } - if ((eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit()) || - (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetRightUnit())) { + if ((eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit()) || + (eStyleUnit_Inherit == mStyleMargin->mMargin.GetRightUnit())) { margin.right = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetRightUnit(), - mStyleSpacing->mMargin.GetRight(right), + mStyleMargin->mMargin.GetRightUnit(), + mStyleMargin->mMargin.GetRight(right), margin.right); } } @@ -843,10 +847,10 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsIPresContext* aPresContext, // The specified offsets are relative to the absolute containing block's padding // edge, and our current values are relative to the border edge so translate nsMargin border; - const nsStyleSpacing* spacing; + const nsStyleBorder* borderStyle; - aAbsoluteContainingBlockFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (!spacing->GetBorder(border)) { + aAbsoluteContainingBlockFrame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderStyle); + if (!borderStyle->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aHypotheticalBox.mLeft -= border.left; @@ -964,8 +968,8 @@ nsHTMLReflowState::InitAbsoluteConstraints(nsIPresContext* aPresContext, } else { // Calculate any 'auto' margin values - PRBool marginLeftIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit()); - PRBool marginRightIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit()); + PRBool marginLeftIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit()); + PRBool marginRightIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit()); PRInt32 availMarginSpace = availContentSpace - mComputedWidth; if (marginLeftIsAuto) { @@ -1167,8 +1171,8 @@ nsHTMLReflowState::InitAbsoluteConstraints(nsIPresContext* aPresContext, } else { // Calculate any 'auto' margin values - PRBool marginTopIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetTopUnit()); - PRBool marginBottomIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetBottomUnit()); + PRBool marginTopIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetTopUnit()); + PRBool marginBottomIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetBottomUnit()); PRInt32 availMarginSpace = availContentSpace - mComputedHeight; if (marginTopIsAuto) { @@ -1531,7 +1535,7 @@ nsHTMLReflowState::InitConstraints(nsIPresContext* aPresContext, // inline-non-replaced elements ComputeMargin(aContainingBlockWidth, cbrs); ComputePadding(aContainingBlockWidth, cbrs); - if (!mStyleSpacing->GetBorder(mComputedBorderPadding)) { + if (!mStyleBorder->GetBorder(mComputedBorderPadding)) { // CSS2 has no percentage borders mComputedBorderPadding.SizeTo(0, 0, 0, 0); } @@ -1858,10 +1862,10 @@ nsHTMLReflowState::ComputeBlockBoxData(nsIPresContext* aPresContext, mComputedWidth = 0; // XXX temp fix for trees } else if (nsLayoutAtoms::tableFrame == fType.get()) { mComputedWidth = NS_SHRINKWRAPWIDTH; - if (eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit()) { mComputedMargin.left = NS_AUTOMARGIN; } - if (eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit()) { mComputedMargin.right = NS_AUTOMARGIN; } } else { @@ -1997,9 +2001,9 @@ nsHTMLReflowState::CalculateBlockSideMargins(nscoord aAvailWidth, // Determine the left and right margin values. The width value // remains constant while we do this. PRBool isAutoLeftMargin = - eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit(); + eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit(); PRBool isAutoRightMargin = - eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit(); + eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit(); // Calculate how much space is available for margins nscoord availMarginSpace = aAvailWidth - aComputedWidth - @@ -2291,42 +2295,42 @@ nsHTMLReflowState::ComputeMargin(nscoord aContainingBlockWidth, const nsHTMLReflowState* aContainingBlockRS) { // If style style can provide us the margin directly, then use it. - if (!mStyleSpacing->GetMargin(mComputedMargin)) { + if (!mStyleMargin->GetMargin(mComputedMargin)) { // We have to compute the value if (NS_UNCONSTRAINEDSIZE == aContainingBlockWidth) { mComputedMargin.left = 0; mComputedMargin.right = 0; - if (eStyleUnit_Coord == mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Coord == mStyleMargin->mMargin.GetLeftUnit()) { nsStyleCoord left; - mStyleSpacing->mMargin.GetLeft(left), + mStyleMargin->mMargin.GetLeft(left), mComputedMargin.left = left.GetCoordValue(); } - if (eStyleUnit_Coord == mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Coord == mStyleMargin->mMargin.GetRightUnit()) { nsStyleCoord right; - mStyleSpacing->mMargin.GetRight(right), + mStyleMargin->mMargin.GetRight(right), mComputedMargin.right = right.GetCoordValue(); } } else { nsStyleCoord left, right; - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetLeftUnit()) { mComputedMargin.left = aContainingBlockRS->mComputedMargin.left; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetLeftUnit(), - mStyleSpacing->mMargin.GetLeft(left), + mStyleMargin->mMargin.GetLeftUnit(), + mStyleMargin->mMargin.GetLeft(left), mComputedMargin.left); } - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetRightUnit()) { mComputedMargin.right = aContainingBlockRS->mComputedMargin.right; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetRightUnit(), - mStyleSpacing->mMargin.GetRight(right), + mStyleMargin->mMargin.GetRightUnit(), + mStyleMargin->mMargin.GetRight(right), mComputedMargin.right); } } @@ -2337,20 +2341,20 @@ nsHTMLReflowState::ComputeMargin(nscoord aContainingBlockWidth, // According to the CSS2 spec, margin percentages are // calculated with respect to the *height* of the containing // block when in a paginated context. - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetTopUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetTopUnit()) { mComputedMargin.top = aContainingBlockRS->mComputedMargin.top; } else { ComputeVerticalValue(rs2->mComputedHeight, - mStyleSpacing->mMargin.GetTopUnit(), - mStyleSpacing->mMargin.GetTop(top), + mStyleMargin->mMargin.GetTopUnit(), + mStyleMargin->mMargin.GetTop(top), mComputedMargin.top); } - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetBottomUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetBottomUnit()) { mComputedMargin.bottom = aContainingBlockRS->mComputedMargin.bottom; } else { ComputeVerticalValue(rs2->mComputedHeight, - mStyleSpacing->mMargin.GetBottomUnit(), - mStyleSpacing->mMargin.GetBottom(bottom), + mStyleMargin->mMargin.GetBottomUnit(), + mStyleMargin->mMargin.GetBottom(bottom), mComputedMargin.bottom); } } @@ -2363,20 +2367,20 @@ nsHTMLReflowState::ComputeMargin(nscoord aContainingBlockWidth, mComputedMargin.bottom = 0; } else { - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetTopUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetTopUnit()) { mComputedMargin.top = aContainingBlockRS->mComputedMargin.top; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetTopUnit(), - mStyleSpacing->mMargin.GetTop(top), + mStyleMargin->mMargin.GetTopUnit(), + mStyleMargin->mMargin.GetTop(top), mComputedMargin.top); } - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetBottomUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetBottomUnit()) { mComputedMargin.bottom = aContainingBlockRS->mComputedMargin.bottom; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetBottomUnit(), - mStyleSpacing->mMargin.GetBottom(bottom), + mStyleMargin->mMargin.GetBottomUnit(), + mStyleMargin->mMargin.GetBottom(bottom), mComputedMargin.bottom); } } @@ -2390,43 +2394,43 @@ nsHTMLReflowState::ComputePadding(nscoord aContainingBlockWidth, { // If style can provide us the padding directly, then use it. - if (!mStyleSpacing->GetPadding(mComputedPadding)) { + if (!mStylePadding->GetPadding(mComputedPadding)) { // We have to compute the value nsStyleCoord left, right, top, bottom; - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetLeftUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetLeftUnit()) { mComputedPadding.left = aContainingBlockRS->mComputedPadding.left; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetLeftUnit(), - mStyleSpacing->mPadding.GetLeft(left), + mStylePadding->mPadding.GetLeftUnit(), + mStylePadding->mPadding.GetLeft(left), mComputedPadding.left); } - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetRightUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetRightUnit()) { mComputedPadding.right = aContainingBlockRS->mComputedPadding.right; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetRightUnit(), - mStyleSpacing->mPadding.GetRight(right), + mStylePadding->mPadding.GetRightUnit(), + mStylePadding->mPadding.GetRight(right), mComputedPadding.right); } // According to the CSS2 spec, percentages are calculated with respect to // containing block width for padding-top and padding-bottom - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetTopUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetTopUnit()) { mComputedPadding.top = aContainingBlockRS->mComputedPadding.top; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetTopUnit(), - mStyleSpacing->mPadding.GetTop(top), + mStylePadding->mPadding.GetTopUnit(), + mStylePadding->mPadding.GetTop(top), mComputedPadding.top); } - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetBottomUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetBottomUnit()) { mComputedPadding.bottom = aContainingBlockRS->mComputedPadding.bottom; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetBottomUnit(), - mStyleSpacing->mPadding.GetBottom(bottom), + mStylePadding->mPadding.GetBottomUnit(), + mStylePadding->mPadding.GetBottom(bottom), mComputedPadding.bottom); } } diff --git a/mozilla/layout/generic/nsHTMLReflowState.h b/mozilla/layout/generic/nsHTMLReflowState.h index 87fed2cdbf6..bf4686d0ff9 100644 --- a/mozilla/layout/generic/nsHTMLReflowState.h +++ b/mozilla/layout/generic/nsHTMLReflowState.h @@ -33,7 +33,9 @@ class nsLineLayout; struct nsStyleDisplay; struct nsStylePosition; -struct nsStyleSpacing; +struct nsStyleBorder; +struct nsStyleMargin; +struct nsStylePadding; struct nsStyleText; struct nsHypotheticalBox; @@ -206,7 +208,9 @@ struct nsHTMLReflowState { // Cached pointers to the various style structs used during intialization const nsStyleDisplay* mStyleDisplay; const nsStylePosition* mStylePosition; - const nsStyleSpacing* mStyleSpacing; + const nsStyleBorder* mStyleBorder; + const nsStyleMargin* mStyleMargin; + const nsStylePadding* mStylePadding; const nsStyleText* mStyleText; // This value keeps track of how deeply nested a given reflow state diff --git a/mozilla/layout/generic/nsIFrame.h b/mozilla/layout/generic/nsIFrame.h index e7580093633..2e5609c9097 100644 --- a/mozilla/layout/generic/nsIFrame.h +++ b/mozilla/layout/generic/nsIFrame.h @@ -621,6 +621,10 @@ public: */ NS_IMETHOD GetStyleData(nsStyleStructID aSID, const nsStyleStruct*& aStyleStruct) const = 0; + // Fill a style struct with data + NS_IMETHOD GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const = 0; + // Utility function: more convenient than 2 calls to GetStyleData to get border and padding + NS_IMETHOD CalcBorderPadding(nsMargin& aBorderPadding) const = 0; /** * These methods are to access any additional style contexts that diff --git a/mozilla/layout/generic/nsImageFrame.cpp b/mozilla/layout/generic/nsImageFrame.cpp index aa58537a089..3d058459c0f 100644 --- a/mozilla/layout/generic/nsImageFrame.cpp +++ b/mozilla/layout/generic/nsImageFrame.cpp @@ -491,9 +491,9 @@ nsImageFrame::DisplayAltText(nsIPresContext* aPresContext, NS_RELEASE(fm); } -struct nsRecessedBorder : public nsStyleSpacing { +struct nsRecessedBorder : public nsStyleBorder { nsRecessedBorder(nscoord aBorderWidth) - : nsStyleSpacing() + : nsStyleBorder() { nsStyleCoord styleCoord(aBorderWidth); @@ -512,7 +512,7 @@ struct nsRecessedBorder : public nsStyleSpacing { mBorderColor[2] = 0; mBorderColor[3] = 0; - mHasCachedMargin = mHasCachedPadding = mHasCachedBorder = PR_FALSE; + mHasCachedBorder = PR_FALSE; } }; diff --git a/mozilla/layout/generic/nsLeafFrame.cpp b/mozilla/layout/generic/nsLeafFrame.cpp index e6b21197498..71b7a4ca1e6 100644 --- a/mozilla/layout/generic/nsLeafFrame.cpp +++ b/mozilla/layout/generic/nsLeafFrame.cpp @@ -45,17 +45,19 @@ nsLeafFrame::Paint(nsIPresContext* aPresContext, if (disp->IsVisibleOrCollapsed()) { const nsStyleColor* myColor = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* myOutline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *myColor, *mySpacing, 0, 0); + aDirtyRect, rect, *myColor, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mStyleContext, 0); + aDirtyRect, rect, *myBorder, mStyleContext, 0); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mStyleContext, 0); + aDirtyRect, rect, *myBorder, *myOutline, mStyleContext, 0); } } return NS_OK; diff --git a/mozilla/layout/generic/nsLineLayout.cpp b/mozilla/layout/generic/nsLineLayout.cpp index 21ec89aeaf0..0bea6b828ed 100644 --- a/mozilla/layout/generic/nsLineLayout.cpp +++ b/mozilla/layout/generic/nsLineLayout.cpp @@ -1570,15 +1570,32 @@ nsLineLayout::IsPercentageAwareReplacedElement(nsIPresContext *aPresContext, if (nsLayoutAtoms::brFrame != frameType.get() && nsLayoutAtoms::textFrame != frameType.get()) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (IsPercentageUnitSides(&space->mMargin) - || IsPercentageUnitSides(&space->mPadding) - || IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -2705,19 +2722,19 @@ nsLineLayout::HorizontalAlignFrames(nsRect& aLineBounds, if (nsLayoutAtoms::hrFrame == frameType.get()) { // get the alignment from the HR frame { - const nsStyleSpacing* spacing; - psd->mFirstFrame->mFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)spacing); + const nsStyleMargin* margin; + psd->mFirstFrame->mFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&)margin); textAlign = NS_STYLE_TEXT_ALIGN_CENTER; nsStyleCoord zero(nscoord(0)); nsStyleCoord temp; - if ((eStyleUnit_Coord==spacing->mMargin.GetLeftUnit()) && - (zero==spacing->mMargin.GetLeft(temp))) + if ((eStyleUnit_Coord==margin->mMargin.GetLeftUnit()) && + (zero==margin->mMargin.GetLeft(temp))) { textAlign = NS_STYLE_TEXT_ALIGN_LEFT; } - else if ((eStyleUnit_Coord==spacing->mMargin.GetRightUnit()) && - (zero==spacing->mMargin.GetRight(temp))) { + else if ((eStyleUnit_Coord==margin->mMargin.GetRightUnit()) && + (zero==margin->mMargin.GetRight(temp))) { textAlign = NS_STYLE_TEXT_ALIGN_RIGHT; } } diff --git a/mozilla/layout/html/base/src/nsAbsoluteContainingBlock.cpp b/mozilla/layout/html/base/src/nsAbsoluteContainingBlock.cpp index c7b7640ebdc..96cf42a16b8 100644 --- a/mozilla/layout/html/base/src/nsAbsoluteContainingBlock.cpp +++ b/mozilla/layout/html/base/src/nsAbsoluteContainingBlock.cpp @@ -381,7 +381,7 @@ nsAbsoluteContainingBlock::ReflowAbsoluteFrame(nsIFrame* aDelegat nsMargin border; // Get the border values - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } diff --git a/mozilla/layout/html/base/src/nsBlockFrame.cpp b/mozilla/layout/html/base/src/nsBlockFrame.cpp index 6ba65c8bb8a..47de6fa7956 100644 --- a/mozilla/layout/html/base/src/nsBlockFrame.cpp +++ b/mozilla/layout/html/base/src/nsBlockFrame.cpp @@ -800,10 +800,10 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, if (mBand.GetFloaterCount()) { // Use the float-edge property to determine how the child block // will interact with the floater. - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - switch (spacing->mFloatEdge) { + const nsStyleBorder* borderStyle; + aFrame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&) borderStyle); + switch (borderStyle->mFloatEdge) { default: case NS_STYLE_FLOAT_EDGE_CONTENT: // content and only content does runaround of floaters // The child block will flow around the floater. Therefore @@ -819,11 +819,14 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, // The child block's border should be placed adjacent to, // but not overlap the floater(s). nsMargin m(0, 0, 0, 0); - spacing->GetMargin(m); // XXX percentage margins - if (NS_STYLE_FLOAT_EDGE_PADDING == spacing->mFloatEdge) { + const nsStyleMargin* styleMargin; + aFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) styleMargin); + styleMargin->GetMargin(m); // XXX percentage margins + if (NS_STYLE_FLOAT_EDGE_PADDING == borderStyle->mFloatEdge) { // Add in border too nsMargin b; - spacing->GetBorder(b); + borderStyle->GetBorder(b); m += b; } @@ -1487,7 +1490,7 @@ CalculateContainingBlock(const nsHTMLReflowState& aReflowState, // Containing block is relative to the padding edge nsMargin border; - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aContainingBlockWidth -= border.left + border.right; @@ -2018,15 +2021,32 @@ HaveAutoWidth(const nsHTMLReflowState& aReflowState) static PRBool IsPercentageAwareChild(const nsIFrame* aFrame) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (nsLineLayout::IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (nsLineLayout::IsPercentageUnitSides(&space->mMargin) - || nsLineLayout::IsPercentageUnitSides(&space->mPadding) - || nsLineLayout::IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -5929,12 +5949,9 @@ nsBlockReflowState::PlaceFloater(nsFloaterCache* aFloaterCache, // Get the type of floater const nsStyleDisplay* floaterDisplay; - const nsStyleSpacing* floaterSpacing; const nsStylePosition* floaterPosition; floater->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)floaterDisplay); - floater->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)floaterSpacing); floater->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&)floaterPosition); @@ -6254,18 +6271,20 @@ nsBlockFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); // Paint background, border and outline nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); } // If overflow is hidden then set the clip rect so that children don't diff --git a/mozilla/layout/html/base/src/nsBlockReflowContext.cpp b/mozilla/layout/html/base/src/nsBlockReflowContext.cpp index 5bdce97e42e..fe76a36e884 100644 --- a/mozilla/layout/html/base/src/nsBlockReflowContext.cpp +++ b/mozilla/layout/html/base/src/nsBlockReflowContext.cpp @@ -58,7 +58,9 @@ nsBlockReflowContext::nsBlockReflowContext(nsIPresContext* aPresContext, mComputeMaximumWidth(aComputeMaximumWidth), mBlockShouldInvalidateItself(PR_FALSE) { - mStyleSpacing = nsnull; + mStyleBorder = nsnull; + mStyleMargin = nsnull; + mStylePadding = nsnull; if (mComputeMaximumWidth) mMetrics.mFlags |= NS_REFLOW_CALC_MAX_WIDTH; } @@ -137,11 +139,11 @@ nsBlockReflowContext::AlignBlockHorizontally(nscoord aWidth, aAlign.mRightMargin = mMargin.right; // Get style unit associated with the left and right margins - nsStyleUnit leftUnit = mStyleSpacing->mMargin.GetLeftUnit(); + nsStyleUnit leftUnit = mStyleMargin->mMargin.GetLeftUnit(); if (eStyleUnit_Inherit == leftUnit) { leftUnit = GetRealMarginLeftUnit(); } - nsStyleUnit rightUnit = mStyleSpacing->mMargin.GetRightUnit(); + nsStyleUnit rightUnit = mStyleMargin->mMargin.GetRightUnit(); if (eStyleUnit_Inherit == rightUnit) { rightUnit = GetRealMarginRightUnit(); } @@ -335,25 +337,25 @@ nsBlockReflowContext::ReflowBlock(nsIFrame* aFrame, } static void -ComputeShrinkwrapMargins(const nsStyleSpacing* aStyleSpacing, nscoord aWidth, nsMargin& aMargin, nscoord& aXToUpdate) { +ComputeShrinkwrapMargins(const nsStyleMargin* aStyleMargin, nscoord aWidth, nsMargin& aMargin, nscoord& aXToUpdate) { nscoord boxWidth = aWidth; float leftPct = 0.0; float rightPct = 0.0; - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetLeftUnit()) { nsStyleCoord leftCoord; - aStyleSpacing->mMargin.GetLeft(leftCoord); + aStyleMargin->mMargin.GetLeft(leftCoord); leftPct = leftCoord.GetPercentValue(); } else { boxWidth += aMargin.left; } - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetRightUnit()) { nsStyleCoord rightCoord; - aStyleSpacing->mMargin.GetRight(rightCoord); + aStyleMargin->mMargin.GetRight(rightCoord); rightPct = rightCoord.GetPercentValue(); } else { @@ -379,11 +381,11 @@ ComputeShrinkwrapMargins(const nsStyleSpacing* aStyleSpacing, nscoord aWidth, ns if ((marginPct > 0.0) && (marginPct < 1.0)) { double shrinkWrapWidth = float(boxWidth) / (1.0 - marginPct); - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetLeftUnit()) { aMargin.left = NSToCoordFloor((float)(shrinkWrapWidth * leftPct)); aXToUpdate += aMargin.left; } - if (eStyleUnit_Percent == aStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Percent == aStyleMargin->mMargin.GetRightUnit()) { aMargin.right = NSToCoordFloor((float)(shrinkWrapWidth * rightPct)); } } @@ -442,7 +444,9 @@ nsBlockReflowContext::DoReflowBlock(nsHTMLReflowState &aReflowState, // from 10.3.3 to determine what to apply. At this point in the // reflow auto left/right margins will have a zero value. mMargin = aReflowState.mComputedMargin; - mStyleSpacing = aReflowState.mStyleSpacing; + mStyleBorder = aReflowState.mStyleBorder; + mStyleMargin = aReflowState.mStyleMargin; + mStylePadding = aReflowState.mStylePadding; nscoord x; nscoord y = aSpace.y + topMargin; @@ -658,7 +662,7 @@ nsBlockReflowContext::DoReflowBlock(nsHTMLReflowState &aReflowState, // based margins. If so, we can calculate them now that we know the shrink // wrap width if (NS_SHRINKWRAPWIDTH == aReflowState.mComputedWidth) { - ComputeShrinkwrapMargins(aReflowState.mStyleSpacing, mMetrics.width, mMargin, mX); + ComputeShrinkwrapMargins(aReflowState.mStyleMargin, mMetrics.width, mMargin, mX); } return rv; @@ -771,15 +775,15 @@ nsBlockReflowContext::PlaceBlock(PRBool aForceFit, if (NS_SHRINKWRAPWIDTH == mComputedWidth) { nscoord dummyXOffset; // Base the margins on the max-element size - ComputeShrinkwrapMargins(mStyleSpacing, m->width, maxElemMargin, dummyXOffset); + ComputeShrinkwrapMargins(mStyleMargin, m->width, maxElemMargin, dummyXOffset); } // Do not allow auto margins to impact the max-element size // since they are springy and don't really count! - if (eStyleUnit_Auto != mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Auto != mStyleMargin->mMargin.GetLeftUnit()) { m->width += maxElemMargin.left; } - if (eStyleUnit_Auto != mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Auto != mStyleMargin->mMargin.GetRightUnit()) { m->width += maxElemMargin.right; } @@ -817,9 +821,9 @@ nsBlockReflowContext::GetRealMarginLeftUnit() NS_RELEASE(sc); sc = psc; if (nsnull != sc) { - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - sc->GetStyleData(eStyleStruct_Spacing); - unit = spacing->mMargin.GetLeftUnit(); + const nsStyleMargin* margin = (const nsStyleMargin*) + sc->GetStyleData(eStyleStruct_Margin); + unit = margin->mMargin.GetLeftUnit(); } } NS_IF_RELEASE(sc); @@ -842,9 +846,9 @@ nsBlockReflowContext::GetRealMarginRightUnit() NS_RELEASE(sc); sc = psc; if (nsnull != sc) { - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - sc->GetStyleData(eStyleStruct_Spacing); - unit = spacing->mMargin.GetRightUnit(); + const nsStyleMargin* margin = (const nsStyleMargin*) + sc->GetStyleData(eStyleStruct_Margin); + unit = margin->mMargin.GetRightUnit(); } } NS_IF_RELEASE(sc); diff --git a/mozilla/layout/html/base/src/nsBlockReflowContext.h b/mozilla/layout/html/base/src/nsBlockReflowContext.h index 308abd13c38..65139793669 100644 --- a/mozilla/layout/html/base/src/nsBlockReflowContext.h +++ b/mozilla/layout/html/base/src/nsBlockReflowContext.h @@ -29,7 +29,6 @@ class nsIFrame; class nsIPresContext; class nsLineLayout; struct nsStylePosition; -struct nsStyleSpacing; struct nsBlockHorizontalAlign; /** @@ -137,7 +136,9 @@ protected: nsIFrame* mNextRCFrame; // Spacing style for the frame we are reflowing; only valid after reflow - const nsStyleSpacing* mStyleSpacing; + const nsStyleBorder* mStyleBorder; + const nsStyleMargin* mStyleMargin; + const nsStylePadding* mStylePadding; nscoord mComputedWidth; // copy of reflowstate's computedWidth nsMargin mMargin; diff --git a/mozilla/layout/html/base/src/nsBlockReflowState.cpp b/mozilla/layout/html/base/src/nsBlockReflowState.cpp index 6ba65c8bb8a..47de6fa7956 100644 --- a/mozilla/layout/html/base/src/nsBlockReflowState.cpp +++ b/mozilla/layout/html/base/src/nsBlockReflowState.cpp @@ -800,10 +800,10 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, if (mBand.GetFloaterCount()) { // Use the float-edge property to determine how the child block // will interact with the floater. - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - switch (spacing->mFloatEdge) { + const nsStyleBorder* borderStyle; + aFrame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&) borderStyle); + switch (borderStyle->mFloatEdge) { default: case NS_STYLE_FLOAT_EDGE_CONTENT: // content and only content does runaround of floaters // The child block will flow around the floater. Therefore @@ -819,11 +819,14 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, // The child block's border should be placed adjacent to, // but not overlap the floater(s). nsMargin m(0, 0, 0, 0); - spacing->GetMargin(m); // XXX percentage margins - if (NS_STYLE_FLOAT_EDGE_PADDING == spacing->mFloatEdge) { + const nsStyleMargin* styleMargin; + aFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) styleMargin); + styleMargin->GetMargin(m); // XXX percentage margins + if (NS_STYLE_FLOAT_EDGE_PADDING == borderStyle->mFloatEdge) { // Add in border too nsMargin b; - spacing->GetBorder(b); + borderStyle->GetBorder(b); m += b; } @@ -1487,7 +1490,7 @@ CalculateContainingBlock(const nsHTMLReflowState& aReflowState, // Containing block is relative to the padding edge nsMargin border; - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aContainingBlockWidth -= border.left + border.right; @@ -2018,15 +2021,32 @@ HaveAutoWidth(const nsHTMLReflowState& aReflowState) static PRBool IsPercentageAwareChild(const nsIFrame* aFrame) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (nsLineLayout::IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (nsLineLayout::IsPercentageUnitSides(&space->mMargin) - || nsLineLayout::IsPercentageUnitSides(&space->mPadding) - || nsLineLayout::IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -5929,12 +5949,9 @@ nsBlockReflowState::PlaceFloater(nsFloaterCache* aFloaterCache, // Get the type of floater const nsStyleDisplay* floaterDisplay; - const nsStyleSpacing* floaterSpacing; const nsStylePosition* floaterPosition; floater->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)floaterDisplay); - floater->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)floaterSpacing); floater->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&)floaterPosition); @@ -6254,18 +6271,20 @@ nsBlockFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); // Paint background, border and outline nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); } // If overflow is hidden then set the clip rect so that children don't diff --git a/mozilla/layout/html/base/src/nsBlockReflowState.h b/mozilla/layout/html/base/src/nsBlockReflowState.h index 6ba65c8bb8a..47de6fa7956 100644 --- a/mozilla/layout/html/base/src/nsBlockReflowState.h +++ b/mozilla/layout/html/base/src/nsBlockReflowState.h @@ -800,10 +800,10 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, if (mBand.GetFloaterCount()) { // Use the float-edge property to determine how the child block // will interact with the floater. - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - switch (spacing->mFloatEdge) { + const nsStyleBorder* borderStyle; + aFrame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&) borderStyle); + switch (borderStyle->mFloatEdge) { default: case NS_STYLE_FLOAT_EDGE_CONTENT: // content and only content does runaround of floaters // The child block will flow around the floater. Therefore @@ -819,11 +819,14 @@ nsBlockReflowState::ComputeBlockAvailSpace(nsIFrame* aFrame, // The child block's border should be placed adjacent to, // but not overlap the floater(s). nsMargin m(0, 0, 0, 0); - spacing->GetMargin(m); // XXX percentage margins - if (NS_STYLE_FLOAT_EDGE_PADDING == spacing->mFloatEdge) { + const nsStyleMargin* styleMargin; + aFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) styleMargin); + styleMargin->GetMargin(m); // XXX percentage margins + if (NS_STYLE_FLOAT_EDGE_PADDING == borderStyle->mFloatEdge) { // Add in border too nsMargin b; - spacing->GetBorder(b); + borderStyle->GetBorder(b); m += b; } @@ -1487,7 +1490,7 @@ CalculateContainingBlock(const nsHTMLReflowState& aReflowState, // Containing block is relative to the padding edge nsMargin border; - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aContainingBlockWidth -= border.left + border.right; @@ -2018,15 +2021,32 @@ HaveAutoWidth(const nsHTMLReflowState& aReflowState) static PRBool IsPercentageAwareChild(const nsIFrame* aFrame) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (nsLineLayout::IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (nsLineLayout::IsPercentageUnitSides(&space->mMargin) - || nsLineLayout::IsPercentageUnitSides(&space->mPadding) - || nsLineLayout::IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (nsLineLayout::IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -5929,12 +5949,9 @@ nsBlockReflowState::PlaceFloater(nsFloaterCache* aFloaterCache, // Get the type of floater const nsStyleDisplay* floaterDisplay; - const nsStyleSpacing* floaterSpacing; const nsStylePosition* floaterPosition; floater->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)floaterDisplay); - floater->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)floaterSpacing); floater->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&)floaterPosition); @@ -6254,18 +6271,20 @@ nsBlockFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); // Paint background, border and outline nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); } // If overflow is hidden then set the clip rect so that children don't diff --git a/mozilla/layout/html/base/src/nsContainerFrame.cpp b/mozilla/layout/html/base/src/nsContainerFrame.cpp index 6a9ec3d0054..f14b4ef8cbf 100644 --- a/mozilla/layout/html/base/src/nsContainerFrame.cpp +++ b/mozilla/layout/html/base/src/nsContainerFrame.cpp @@ -599,18 +599,20 @@ nsContainerFrame::SyncFrameViewAfterReflow(nsIPresContext* aPresContext, } if (hasOverflowClip) { - const nsStyleSpacing* spacing; + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; nsMargin border, padding; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + aFrame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderStyle); + aFrame->GetStyleData(eStyleStruct_Padding, (const nsStyleStruct*&)paddingStyle); // XXX We don't support the 'overflow-clip' property yet so just use the // content area (which is the default value) as the clip shape overflowClipRect.SetRect(0, 0, frameSize.width, frameSize.height); - spacing->GetBorder(border); + borderStyle->GetBorder(border); overflowClipRect.Deflate(border); // XXX We need to handle percentage padding - if (spacing->GetPadding(padding)) { + if (paddingStyle->GetPadding(padding)) { overflowClipRect.Deflate(padding); } } diff --git a/mozilla/layout/html/base/src/nsFrame.cpp b/mozilla/layout/html/base/src/nsFrame.cpp index 96a79aba6ba..eaf4fc5eebe 100644 --- a/mozilla/layout/html/base/src/nsFrame.cpp +++ b/mozilla/layout/html/base/src/nsFrame.cpp @@ -493,6 +493,23 @@ NS_IMETHODIMP nsFrame::GetStyleData(nsStyleStructID aSID, const nsStyleStruct*& return NS_OK; } +NS_IMETHODIMP nsFrame::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const { + NS_ASSERTION(mStyleContext!=nsnull,"null style context"); + if (mStyleContext) { + return mStyleContext->GetStyle(aSID, aStruct); + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP nsFrame::CalcBorderPadding(nsMargin& aBorderPadding) const { + NS_ASSERTION(mStyleContext!=nsnull,"null style context"); + if (mStyleContext) { + mStyleContext->CalcBorderPaddingFor(this, aBorderPadding); + return NS_OK; + } + return NS_ERROR_FAILURE; +} + NS_IMETHODIMP nsFrame::GetAdditionalStyleContext(PRInt32 aIndex, nsIStyleContext** aStyleContext) const @@ -624,8 +641,10 @@ nsFrame::SetOverflowClipRect(nsIRenderingContext& aRenderingContext) // 'overflow-clip' only applies to block-level elements and replaced // elements that have 'overflow' set to 'hidden', and it is relative // to the content area and applies to content only (not border or background) - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderStyle); + GetStyleData(eStyleStruct_Padding, (const nsStyleStruct*&)paddingStyle); // Start with the 'auto' values and then factor in user specified values nsRect clipRect(0, 0, mRect.width, mRect.height); @@ -634,10 +653,10 @@ nsFrame::SetOverflowClipRect(nsIRenderingContext& aRenderingContext) // content area (which is the default value) as the clip shape nsMargin border, padding; - spacing->GetBorder(border); + borderStyle->GetBorder(border); clipRect.Deflate(border); // XXX We need to handle percentage padding - if (spacing->GetPadding(padding)) { + if (paddingStyle->GetPadding(padding)) { clipRect.Deflate(padding); } @@ -2073,10 +2092,10 @@ nsFrame::Invalidate(nsIPresContext* aPresContext, // Checks to see if the damaged rect should be infalted // to include the outline - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + const nsStyleOutline* outline; + GetStyleData(eStyleStruct_Outline, (const nsStyleStruct*&)outline); nscoord width; - spacing->GetOutlineWidth(width); + outline->GetOutlineWidth(width); if (width > 0) { damageRect.Inflate(width, width); } diff --git a/mozilla/layout/html/base/src/nsFrame.h b/mozilla/layout/html/base/src/nsFrame.h index b0ce1c522b2..582c32340d0 100644 --- a/mozilla/layout/html/base/src/nsFrame.h +++ b/mozilla/layout/html/base/src/nsFrame.h @@ -173,6 +173,8 @@ public: nsIStyleContext* aContext); NS_IMETHOD GetStyleData(nsStyleStructID aSID, const nsStyleStruct*& aStyleStruct) const; + NS_IMETHOD GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const; + NS_IMETHOD CalcBorderPadding(nsMargin& aBorderPadding) const; NS_IMETHOD GetAdditionalStyleContext(PRInt32 aIndex, nsIStyleContext** aStyleContext) const; NS_IMETHOD SetAdditionalStyleContext(PRInt32 aIndex, diff --git a/mozilla/layout/html/base/src/nsHRFrame.cpp b/mozilla/layout/html/base/src/nsHRFrame.cpp index 5e33d9c5c7c..1a37e21980c 100644 --- a/mozilla/layout/html/base/src/nsHRFrame.cpp +++ b/mozilla/layout/html/base/src/nsHRFrame.cpp @@ -133,15 +133,15 @@ HRuleFrame::Paint(nsIPresContext* aPresContext, if (!noShadeAttribute) { nsRect rect(x0, y0, width, height); - const nsStyleSpacing* spacing = - (nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); color = (nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this,aDirtyRect, rect, *color, - *spacing, 0, 0); + *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, - this,aDirtyRect, rect, *spacing, + this,aDirtyRect, rect, *border, mStyleContext, 0); } else { nscolor colors[2]; diff --git a/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp b/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp index 1d7c6a12590..d2ffcad073a 100644 --- a/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp +++ b/mozilla/layout/html/base/src/nsHTMLContainerFrame.cpp @@ -73,16 +73,18 @@ nsHTMLContainerFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); // The sole purpose of this is to trigger display // of the selection window for Named Anchors, diff --git a/mozilla/layout/html/base/src/nsHTMLFrame.cpp b/mozilla/layout/html/base/src/nsHTMLFrame.cpp index 5332867867f..12bc4d0cf8e 100644 --- a/mozilla/layout/html/base/src/nsHTMLFrame.cpp +++ b/mozilla/layout/html/base/src/nsHTMLFrame.cpp @@ -304,7 +304,7 @@ CanvasFrame::Reflow(nsIPresContext* aPresContext, nsMargin border; nsFrameState kidState; - if (!kidReflowState.mStyleSpacing->GetBorder(border)) { + if (!kidReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } kidFrame->GetFrameState(&kidState); diff --git a/mozilla/layout/html/base/src/nsHTMLReflowState.cpp b/mozilla/layout/html/base/src/nsHTMLReflowState.cpp index cd61f6ae513..14c16e20834 100644 --- a/mozilla/layout/html/base/src/nsHTMLReflowState.cpp +++ b/mozilla/layout/html/base/src/nsHTMLReflowState.cpp @@ -179,8 +179,12 @@ nsHTMLReflowState::Init(nsIPresContext* aPresContext, (const nsStyleStruct*&)mStylePosition); frame->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&)mStyleDisplay); - frame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)mStyleSpacing); + frame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&)mStyleBorder); + frame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&)mStyleMargin); + frame->GetStyleData(eStyleStruct_Padding, + (const nsStyleStruct*&)mStylePadding); frame->GetStyleData(eStyleStruct_Text, (const nsStyleStruct*&)mStyleText); mFrameType = DetermineFrameType(frame, mStylePosition, mStyleDisplay); @@ -475,10 +479,10 @@ GetNearestContainingBlock(nsIFrame* aFrame, nsMargin& aContentArea) // Subtract off for border and padding. If it can't be computed because // it's percentage based (for example) then just ignore it - nsStyleSpacing* spacing; - nsMargin borderPadding; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing->GetBorderPadding(borderPadding)) { + nsStyleBorderPadding bPad; + nsMargin borderPadding; + aFrame->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (bPad.GetBorderPadding(borderPadding)) { aContentArea.left += borderPadding.left; aContentArea.top += borderPadding.top; aContentArea.right -= borderPadding.right; @@ -534,55 +538,55 @@ nsHTMLReflowState::CalculateHorizBorderPaddingMargin(nscoord aContainingBlockWid nsMargin border, padding, margin; // Get the border - if (!mStyleSpacing->GetBorder(border)) { + if (!mStyleBorder->GetBorder(border)) { // CSS2 has no percentage borders border.SizeTo(0, 0, 0, 0); } // See if the style system can provide us the padding directly - if (!mStyleSpacing->GetPadding(padding)) { + if (!mStylePadding->GetPadding(padding)) { nsStyleCoord left, right; // We have to compute the left and right values - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetLeftUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetLeftUnit()) { padding.left = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetLeftUnit(), - mStyleSpacing->mPadding.GetLeft(left), + mStylePadding->mPadding.GetLeftUnit(), + mStylePadding->mPadding.GetLeft(left), padding.left); } - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetRightUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetRightUnit()) { padding.right = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetRightUnit(), - mStyleSpacing->mPadding.GetRight(right), + mStylePadding->mPadding.GetRightUnit(), + mStylePadding->mPadding.GetRight(right), padding.right); } } // See if the style system can provide us the margin directly - if (!mStyleSpacing->GetMargin(margin)) { + if (!mStyleMargin->GetMargin(margin)) { nsStyleCoord left, right; // We have to compute the left and right values - if ((eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit()) || - (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetLeftUnit())) { + if ((eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit()) || + (eStyleUnit_Inherit == mStyleMargin->mMargin.GetLeftUnit())) { margin.left = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetLeftUnit(), - mStyleSpacing->mMargin.GetLeft(left), + mStyleMargin->mMargin.GetLeftUnit(), + mStyleMargin->mMargin.GetLeft(left), margin.left); } - if ((eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit()) || - (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetRightUnit())) { + if ((eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit()) || + (eStyleUnit_Inherit == mStyleMargin->mMargin.GetRightUnit())) { margin.right = 0; // just ignore } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetRightUnit(), - mStyleSpacing->mMargin.GetRight(right), + mStyleMargin->mMargin.GetRightUnit(), + mStyleMargin->mMargin.GetRight(right), margin.right); } } @@ -843,10 +847,10 @@ nsHTMLReflowState::CalculateHypotheticalBox(nsIPresContext* aPresContext, // The specified offsets are relative to the absolute containing block's padding // edge, and our current values are relative to the border edge so translate nsMargin border; - const nsStyleSpacing* spacing; + const nsStyleBorder* borderStyle; - aAbsoluteContainingBlockFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (!spacing->GetBorder(border)) { + aAbsoluteContainingBlockFrame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderStyle); + if (!borderStyle->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } aHypotheticalBox.mLeft -= border.left; @@ -964,8 +968,8 @@ nsHTMLReflowState::InitAbsoluteConstraints(nsIPresContext* aPresContext, } else { // Calculate any 'auto' margin values - PRBool marginLeftIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit()); - PRBool marginRightIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit()); + PRBool marginLeftIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit()); + PRBool marginRightIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit()); PRInt32 availMarginSpace = availContentSpace - mComputedWidth; if (marginLeftIsAuto) { @@ -1167,8 +1171,8 @@ nsHTMLReflowState::InitAbsoluteConstraints(nsIPresContext* aPresContext, } else { // Calculate any 'auto' margin values - PRBool marginTopIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetTopUnit()); - PRBool marginBottomIsAuto = (eStyleUnit_Auto == mStyleSpacing->mMargin.GetBottomUnit()); + PRBool marginTopIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetTopUnit()); + PRBool marginBottomIsAuto = (eStyleUnit_Auto == mStyleMargin->mMargin.GetBottomUnit()); PRInt32 availMarginSpace = availContentSpace - mComputedHeight; if (marginTopIsAuto) { @@ -1531,7 +1535,7 @@ nsHTMLReflowState::InitConstraints(nsIPresContext* aPresContext, // inline-non-replaced elements ComputeMargin(aContainingBlockWidth, cbrs); ComputePadding(aContainingBlockWidth, cbrs); - if (!mStyleSpacing->GetBorder(mComputedBorderPadding)) { + if (!mStyleBorder->GetBorder(mComputedBorderPadding)) { // CSS2 has no percentage borders mComputedBorderPadding.SizeTo(0, 0, 0, 0); } @@ -1858,10 +1862,10 @@ nsHTMLReflowState::ComputeBlockBoxData(nsIPresContext* aPresContext, mComputedWidth = 0; // XXX temp fix for trees } else if (nsLayoutAtoms::tableFrame == fType.get()) { mComputedWidth = NS_SHRINKWRAPWIDTH; - if (eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit()) { mComputedMargin.left = NS_AUTOMARGIN; } - if (eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit()) { mComputedMargin.right = NS_AUTOMARGIN; } } else { @@ -1997,9 +2001,9 @@ nsHTMLReflowState::CalculateBlockSideMargins(nscoord aAvailWidth, // Determine the left and right margin values. The width value // remains constant while we do this. PRBool isAutoLeftMargin = - eStyleUnit_Auto == mStyleSpacing->mMargin.GetLeftUnit(); + eStyleUnit_Auto == mStyleMargin->mMargin.GetLeftUnit(); PRBool isAutoRightMargin = - eStyleUnit_Auto == mStyleSpacing->mMargin.GetRightUnit(); + eStyleUnit_Auto == mStyleMargin->mMargin.GetRightUnit(); // Calculate how much space is available for margins nscoord availMarginSpace = aAvailWidth - aComputedWidth - @@ -2291,42 +2295,42 @@ nsHTMLReflowState::ComputeMargin(nscoord aContainingBlockWidth, const nsHTMLReflowState* aContainingBlockRS) { // If style style can provide us the margin directly, then use it. - if (!mStyleSpacing->GetMargin(mComputedMargin)) { + if (!mStyleMargin->GetMargin(mComputedMargin)) { // We have to compute the value if (NS_UNCONSTRAINEDSIZE == aContainingBlockWidth) { mComputedMargin.left = 0; mComputedMargin.right = 0; - if (eStyleUnit_Coord == mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Coord == mStyleMargin->mMargin.GetLeftUnit()) { nsStyleCoord left; - mStyleSpacing->mMargin.GetLeft(left), + mStyleMargin->mMargin.GetLeft(left), mComputedMargin.left = left.GetCoordValue(); } - if (eStyleUnit_Coord == mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Coord == mStyleMargin->mMargin.GetRightUnit()) { nsStyleCoord right; - mStyleSpacing->mMargin.GetRight(right), + mStyleMargin->mMargin.GetRight(right), mComputedMargin.right = right.GetCoordValue(); } } else { nsStyleCoord left, right; - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetLeftUnit()) { mComputedMargin.left = aContainingBlockRS->mComputedMargin.left; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetLeftUnit(), - mStyleSpacing->mMargin.GetLeft(left), + mStyleMargin->mMargin.GetLeftUnit(), + mStyleMargin->mMargin.GetLeft(left), mComputedMargin.left); } - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetRightUnit()) { mComputedMargin.right = aContainingBlockRS->mComputedMargin.right; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetRightUnit(), - mStyleSpacing->mMargin.GetRight(right), + mStyleMargin->mMargin.GetRightUnit(), + mStyleMargin->mMargin.GetRight(right), mComputedMargin.right); } } @@ -2337,20 +2341,20 @@ nsHTMLReflowState::ComputeMargin(nscoord aContainingBlockWidth, // According to the CSS2 spec, margin percentages are // calculated with respect to the *height* of the containing // block when in a paginated context. - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetTopUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetTopUnit()) { mComputedMargin.top = aContainingBlockRS->mComputedMargin.top; } else { ComputeVerticalValue(rs2->mComputedHeight, - mStyleSpacing->mMargin.GetTopUnit(), - mStyleSpacing->mMargin.GetTop(top), + mStyleMargin->mMargin.GetTopUnit(), + mStyleMargin->mMargin.GetTop(top), mComputedMargin.top); } - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetBottomUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetBottomUnit()) { mComputedMargin.bottom = aContainingBlockRS->mComputedMargin.bottom; } else { ComputeVerticalValue(rs2->mComputedHeight, - mStyleSpacing->mMargin.GetBottomUnit(), - mStyleSpacing->mMargin.GetBottom(bottom), + mStyleMargin->mMargin.GetBottomUnit(), + mStyleMargin->mMargin.GetBottom(bottom), mComputedMargin.bottom); } } @@ -2363,20 +2367,20 @@ nsHTMLReflowState::ComputeMargin(nscoord aContainingBlockWidth, mComputedMargin.bottom = 0; } else { - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetTopUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetTopUnit()) { mComputedMargin.top = aContainingBlockRS->mComputedMargin.top; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetTopUnit(), - mStyleSpacing->mMargin.GetTop(top), + mStyleMargin->mMargin.GetTopUnit(), + mStyleMargin->mMargin.GetTop(top), mComputedMargin.top); } - if (eStyleUnit_Inherit == mStyleSpacing->mMargin.GetBottomUnit()) { + if (eStyleUnit_Inherit == mStyleMargin->mMargin.GetBottomUnit()) { mComputedMargin.bottom = aContainingBlockRS->mComputedMargin.bottom; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mMargin.GetBottomUnit(), - mStyleSpacing->mMargin.GetBottom(bottom), + mStyleMargin->mMargin.GetBottomUnit(), + mStyleMargin->mMargin.GetBottom(bottom), mComputedMargin.bottom); } } @@ -2390,43 +2394,43 @@ nsHTMLReflowState::ComputePadding(nscoord aContainingBlockWidth, { // If style can provide us the padding directly, then use it. - if (!mStyleSpacing->GetPadding(mComputedPadding)) { + if (!mStylePadding->GetPadding(mComputedPadding)) { // We have to compute the value nsStyleCoord left, right, top, bottom; - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetLeftUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetLeftUnit()) { mComputedPadding.left = aContainingBlockRS->mComputedPadding.left; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetLeftUnit(), - mStyleSpacing->mPadding.GetLeft(left), + mStylePadding->mPadding.GetLeftUnit(), + mStylePadding->mPadding.GetLeft(left), mComputedPadding.left); } - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetRightUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetRightUnit()) { mComputedPadding.right = aContainingBlockRS->mComputedPadding.right; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetRightUnit(), - mStyleSpacing->mPadding.GetRight(right), + mStylePadding->mPadding.GetRightUnit(), + mStylePadding->mPadding.GetRight(right), mComputedPadding.right); } // According to the CSS2 spec, percentages are calculated with respect to // containing block width for padding-top and padding-bottom - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetTopUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetTopUnit()) { mComputedPadding.top = aContainingBlockRS->mComputedPadding.top; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetTopUnit(), - mStyleSpacing->mPadding.GetTop(top), + mStylePadding->mPadding.GetTopUnit(), + mStylePadding->mPadding.GetTop(top), mComputedPadding.top); } - if (eStyleUnit_Inherit == mStyleSpacing->mPadding.GetBottomUnit()) { + if (eStyleUnit_Inherit == mStylePadding->mPadding.GetBottomUnit()) { mComputedPadding.bottom = aContainingBlockRS->mComputedPadding.bottom; } else { ComputeHorizontalValue(aContainingBlockWidth, - mStyleSpacing->mPadding.GetBottomUnit(), - mStyleSpacing->mPadding.GetBottom(bottom), + mStylePadding->mPadding.GetBottomUnit(), + mStylePadding->mPadding.GetBottom(bottom), mComputedPadding.bottom); } } diff --git a/mozilla/layout/html/base/src/nsImageFrame.cpp b/mozilla/layout/html/base/src/nsImageFrame.cpp index aa58537a089..3d058459c0f 100644 --- a/mozilla/layout/html/base/src/nsImageFrame.cpp +++ b/mozilla/layout/html/base/src/nsImageFrame.cpp @@ -491,9 +491,9 @@ nsImageFrame::DisplayAltText(nsIPresContext* aPresContext, NS_RELEASE(fm); } -struct nsRecessedBorder : public nsStyleSpacing { +struct nsRecessedBorder : public nsStyleBorder { nsRecessedBorder(nscoord aBorderWidth) - : nsStyleSpacing() + : nsStyleBorder() { nsStyleCoord styleCoord(aBorderWidth); @@ -512,7 +512,7 @@ struct nsRecessedBorder : public nsStyleSpacing { mBorderColor[2] = 0; mBorderColor[3] = 0; - mHasCachedMargin = mHasCachedPadding = mHasCachedBorder = PR_FALSE; + mHasCachedBorder = PR_FALSE; } }; diff --git a/mozilla/layout/html/base/src/nsLeafFrame.cpp b/mozilla/layout/html/base/src/nsLeafFrame.cpp index e6b21197498..71b7a4ca1e6 100644 --- a/mozilla/layout/html/base/src/nsLeafFrame.cpp +++ b/mozilla/layout/html/base/src/nsLeafFrame.cpp @@ -45,17 +45,19 @@ nsLeafFrame::Paint(nsIPresContext* aPresContext, if (disp->IsVisibleOrCollapsed()) { const nsStyleColor* myColor = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* myOutline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *myColor, *mySpacing, 0, 0); + aDirtyRect, rect, *myColor, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mStyleContext, 0); + aDirtyRect, rect, *myBorder, mStyleContext, 0); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mStyleContext, 0); + aDirtyRect, rect, *myBorder, *myOutline, mStyleContext, 0); } } return NS_OK; diff --git a/mozilla/layout/html/base/src/nsLineLayout.cpp b/mozilla/layout/html/base/src/nsLineLayout.cpp index 21ec89aeaf0..0bea6b828ed 100644 --- a/mozilla/layout/html/base/src/nsLineLayout.cpp +++ b/mozilla/layout/html/base/src/nsLineLayout.cpp @@ -1570,15 +1570,32 @@ nsLineLayout::IsPercentageAwareReplacedElement(nsIPresContext *aPresContext, if (nsLayoutAtoms::brFrame != frameType.get() && nsLayoutAtoms::textFrame != frameType.get()) { - const nsStyleSpacing* space; - nsresult rv = aFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct*&) space); + nsresult rv; + + const nsStyleMargin* margin; + rv = aFrame->GetStyleData(eStyleStruct_Margin,(const nsStyleStruct*&) margin); if (NS_FAILED(rv)) { return PR_TRUE; // just to be on the safe side } + if (IsPercentageUnitSides(&margin->mMargin)) { + return PR_TRUE; + } - if (IsPercentageUnitSides(&space->mMargin) - || IsPercentageUnitSides(&space->mPadding) - || IsPercentageUnitSides(&space->mBorderRadius)) { + const nsStylePadding* padding; + rv = aFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct*&) padding); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (IsPercentageUnitSides(&padding->mPadding)) { + return PR_TRUE; + } + + const nsStyleBorder* border; + rv = aFrame->GetStyleData(eStyleStruct_Border,(const nsStyleStruct*&) border); + if (NS_FAILED(rv)) { + return PR_TRUE; // just to be on the safe side + } + if (IsPercentageUnitSides(&border->mBorder)) { return PR_TRUE; } @@ -2705,19 +2722,19 @@ nsLineLayout::HorizontalAlignFrames(nsRect& aLineBounds, if (nsLayoutAtoms::hrFrame == frameType.get()) { // get the alignment from the HR frame { - const nsStyleSpacing* spacing; - psd->mFirstFrame->mFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&)spacing); + const nsStyleMargin* margin; + psd->mFirstFrame->mFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&)margin); textAlign = NS_STYLE_TEXT_ALIGN_CENTER; nsStyleCoord zero(nscoord(0)); nsStyleCoord temp; - if ((eStyleUnit_Coord==spacing->mMargin.GetLeftUnit()) && - (zero==spacing->mMargin.GetLeft(temp))) + if ((eStyleUnit_Coord==margin->mMargin.GetLeftUnit()) && + (zero==margin->mMargin.GetLeft(temp))) { textAlign = NS_STYLE_TEXT_ALIGN_LEFT; } - else if ((eStyleUnit_Coord==spacing->mMargin.GetRightUnit()) && - (zero==spacing->mMargin.GetRight(temp))) { + else if ((eStyleUnit_Coord==margin->mMargin.GetRightUnit()) && + (zero==margin->mMargin.GetRight(temp))) { textAlign = NS_STYLE_TEXT_ALIGN_RIGHT; } } diff --git a/mozilla/layout/html/content/src/nsGenericHTMLElement.cpp b/mozilla/layout/html/content/src/nsGenericHTMLElement.cpp index c4eff0bce19..11daa218e35 100644 --- a/mozilla/layout/html/content/src/nsGenericHTMLElement.cpp +++ b/mozilla/layout/html/content/src/nsGenericHTMLElement.cpp @@ -715,28 +715,28 @@ nsGenericHTMLElement::GetOffsetRect(nsRect& aRect, } // For the origin, add in the border for the frame - const nsStyleSpacing* spacing; + const nsStyleBorder* border; nsStyleCoord coord; - frame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); + frame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + if (border) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); } } // And subtract out the border for the parent if (parent) { - const nsStyleSpacing* parentSpacing; - parent->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)parentSpacing); - if (parentSpacing) { - if (eStyleUnit_Coord == parentSpacing->mBorder.GetLeftUnit()) { - origin.x -= parentSpacing->mBorder.GetLeft(coord).GetCoordValue(); + const nsStyleBorder* parentBorder; + parent->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)parentBorder); + if (parentBorder) { + if (eStyleUnit_Coord == parentBorder->mBorder.GetLeftUnit()) { + origin.x -= parentBorder->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == parentSpacing->mBorder.GetTopUnit()) { - origin.y -= parentSpacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == parentBorder->mBorder.GetTopUnit()) { + origin.y -= parentBorder->mBorder.GetTop(coord).GetCoordValue(); } } } @@ -2911,8 +2911,8 @@ nsGenericHTMLElement::MapImageAttributesInto(const nsIHTMLMappedAttributes* aAtt aPresContext->GetScaledPixelsToTwips(&p2t); nsStylePosition* pos = (nsStylePosition*) aContext->GetMutableStyleData(eStyleStruct_Position); - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); // width: value aAttributes->GetAttribute(nsHTMLAtoms::width, value); @@ -2939,13 +2939,13 @@ nsGenericHTMLElement::MapImageAttributesInto(const nsIHTMLMappedAttributes* aAtt if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), p2t); nsStyleCoord c(twips); - spacing->mMargin.SetLeft(c); - spacing->mMargin.SetRight(c); + margin->mMargin.SetLeft(c); + margin->mMargin.SetRight(c); } else if (value.GetUnit() == eHTMLUnit_Percent) { nsStyleCoord c(value.GetPercentValue(), eStyleUnit_Percent); - spacing->mMargin.SetLeft(c); - spacing->mMargin.SetRight(c); + margin->mMargin.SetLeft(c); + margin->mMargin.SetRight(c); } // vspace: value @@ -2953,13 +2953,13 @@ nsGenericHTMLElement::MapImageAttributesInto(const nsIHTMLMappedAttributes* aAtt if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), p2t); nsStyleCoord c(twips); - spacing->mMargin.SetTop(c); - spacing->mMargin.SetBottom(c); + margin->mMargin.SetTop(c); + margin->mMargin.SetBottom(c); } else if (value.GetUnit() == eHTMLUnit_Percent) { nsStyleCoord c(value.GetPercentValue(), eStyleUnit_Percent); - spacing->mMargin.SetTop(c); - spacing->mMargin.SetBottom(c); + margin->mMargin.SetTop(c); + margin->mMargin.SetBottom(c); } } @@ -2990,21 +2990,21 @@ nsGenericHTMLElement::MapImageAlignAttributeInto(const nsIHTMLMappedAttributes* aContext->GetMutableStyleData(eStyleStruct_Display); nsStyleText* text = (nsStyleText*) aContext->GetMutableStyleData(eStyleStruct_Text); - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); float p2t; aPresContext->GetScaledPixelsToTwips(&p2t); nsStyleCoord three(NSIntPixelsToTwips(3, p2t)); switch (align) { case NS_STYLE_TEXT_ALIGN_LEFT: display->mFloats = NS_STYLE_FLOAT_LEFT; - spacing->mMargin.SetLeft(three); - spacing->mMargin.SetRight(three); + margin->mMargin.SetLeft(three); + margin->mMargin.SetRight(three); break; case NS_STYLE_TEXT_ALIGN_RIGHT: display->mFloats = NS_STYLE_FLOAT_RIGHT; - spacing->mMargin.SetLeft(three); - spacing->mMargin.SetRight(three); + margin->mMargin.SetLeft(three); + margin->mMargin.SetRight(three); break; default: text->mVerticalAlign.SetIntValue(align, eStyleUnit_Enumerated); @@ -3053,38 +3053,39 @@ nsGenericHTMLElement::MapImageBorderAttributeInto(const nsIHTMLMappedAttributes* // Fixup border-padding sums: subtract out the old size and then // add in the new size. - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + nsStyleCoord coord; coord.SetCoordValue(twips); - spacing->mBorder.SetTop(coord); - spacing->mBorder.SetRight(coord); - spacing->mBorder.SetBottom(coord); - spacing->mBorder.SetLeft(coord); + border->mBorder.SetTop(coord); + border->mBorder.SetRight(coord); + border->mBorder.SetBottom(coord); + border->mBorder.SetLeft(coord); - spacing->SetBorderStyle(0,NS_STYLE_BORDER_STYLE_SOLID); - spacing->SetBorderStyle(1,NS_STYLE_BORDER_STYLE_SOLID); - spacing->SetBorderStyle(2,NS_STYLE_BORDER_STYLE_SOLID); - spacing->SetBorderStyle(3,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(0,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(1,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(2,NS_STYLE_BORDER_STYLE_SOLID); + border->SetBorderStyle(3,NS_STYLE_BORDER_STYLE_SOLID); // Use supplied colors if provided, otherwise use color for border // color if (nsnull != aBorderColors) { - spacing->SetBorderColor(0, aBorderColors[0]); - spacing->SetBorderColor(1, aBorderColors[1]); - spacing->SetBorderColor(2, aBorderColors[2]); - spacing->SetBorderColor(3, aBorderColors[3]); + border->SetBorderColor(0, aBorderColors[0]); + border->SetBorderColor(1, aBorderColors[1]); + border->SetBorderColor(2, aBorderColors[2]); + border->SetBorderColor(3, aBorderColors[3]); } else { // Color is inherited from "color" const nsStyleColor* styleColor = (const nsStyleColor*) aContext->GetStyleData(eStyleStruct_Color); nscolor color = styleColor->mColor; - spacing->SetBorderColor(0, color); - spacing->SetBorderColor(1, color); - spacing->SetBorderColor(2, color); - spacing->SetBorderColor(3, color); + border->SetBorderColor(0, color); + border->SetBorderColor(1, color); + border->SetBorderColor(2, color); + border->SetBorderColor(3, color); } } diff --git a/mozilla/layout/html/content/src/nsHTMLBodyElement.cpp b/mozilla/layout/html/content/src/nsHTMLBodyElement.cpp index 066c79c28b1..b0f7073b946 100644 --- a/mozilla/layout/html/content/src/nsHTMLBodyElement.cpp +++ b/mozilla/layout/html/content/src/nsHTMLBodyElement.cpp @@ -293,9 +293,9 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, nsIPresContext* aPresContext) { if (mPart) { - nsStyleSpacing* styleSpacing = (nsStyleSpacing*)(aContext->GetMutableStyleData(eStyleStruct_Spacing)); + nsStyleMargin* marginStyle = (nsStyleMargin*)(aContext->GetMutableStyleData(eStyleStruct_Margin)); - if (nsnull != styleSpacing) { + if (nsnull != marginStyle) { nsHTMLValue value; PRInt32 attrCount; float p2t; @@ -313,8 +313,8 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, bodyMarginWidth = 0; } nsStyleCoord widthCoord(bodyMarginWidth); - styleSpacing->mMargin.SetLeft(widthCoord); - styleSpacing->mMargin.SetRight(widthCoord); + marginStyle->mMargin.SetLeft(widthCoord); + marginStyle->mMargin.SetRight(widthCoord); } mPart->GetHTMLAttribute(nsHTMLAtoms::marginheight, value); @@ -325,8 +325,8 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, } nsStyleCoord heightCoord(bodyMarginHeight); - styleSpacing->mMargin.SetTop(heightCoord); - styleSpacing->mMargin.SetBottom(heightCoord); + marginStyle->mMargin.SetTop(heightCoord); + marginStyle->mMargin.SetBottom(heightCoord); } } @@ -363,14 +363,14 @@ BodyRule::MapStyleInto(nsIMutableStyleContext* aContext, if ((0 > bodyMarginWidth) && (frameMarginWidth >= 0)) { nsStyleCoord widthCoord(frameMarginWidth); - styleSpacing->mMargin.SetLeft(widthCoord); - styleSpacing->mMargin.SetRight(widthCoord); + marginStyle->mMargin.SetLeft(widthCoord); + marginStyle->mMargin.SetRight(widthCoord); } if ((0 > bodyMarginHeight) && (frameMarginHeight >= 0)) { nsStyleCoord heightCoord(frameMarginHeight); - styleSpacing->mMargin.SetTop(heightCoord); - styleSpacing->mMargin.SetBottom(heightCoord); + marginStyle->mMargin.SetTop(heightCoord); + marginStyle->mMargin.SetBottom(heightCoord); } } NS_RELEASE(container); diff --git a/mozilla/layout/html/content/src/nsHTMLHRElement.cpp b/mozilla/layout/html/content/src/nsHTMLHRElement.cpp index 7aa089ed8e9..acf8bae427d 100644 --- a/mozilla/layout/html/content/src/nsHTMLHRElement.cpp +++ b/mozilla/layout/html/content/src/nsHTMLHRElement.cpp @@ -207,22 +207,22 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, aAttributes->GetAttribute(nsHTMLAtoms::align, value); if (eHTMLUnit_Enumerated == value.GetUnit()) { // Map align attribute into auto side margins - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); nsStyleCoord otto(eStyleUnit_Auto); nsStyleCoord zero(nscoord(0)); switch (value.GetIntValue()) { case NS_STYLE_TEXT_ALIGN_LEFT: - spacing->mMargin.SetLeft(zero); - spacing->mMargin.SetRight(otto); + margin->mMargin.SetLeft(zero); + margin->mMargin.SetRight(otto); break; case NS_STYLE_TEXT_ALIGN_RIGHT: - spacing->mMargin.SetLeft(otto); - spacing->mMargin.SetRight(zero); + margin->mMargin.SetLeft(otto); + margin->mMargin.SetRight(zero); break; case NS_STYLE_TEXT_ALIGN_CENTER: - spacing->mMargin.SetLeft(otto); - spacing->mMargin.SetRight(otto); + margin->mMargin.SetLeft(otto); + margin->mMargin.SetRight(otto); break; } } diff --git a/mozilla/layout/html/content/src/nsHTMLIFrameElement.cpp b/mozilla/layout/html/content/src/nsHTMLIFrameElement.cpp index 512bc71739f..2f1c1824d2d 100644 --- a/mozilla/layout/html/content/src/nsHTMLIFrameElement.cpp +++ b/mozilla/layout/html/content/src/nsHTMLIFrameElement.cpp @@ -314,15 +314,15 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if (NS_STYLE_FRAME_0 == frameborder || NS_STYLE_FRAME_NO == frameborder || NS_STYLE_FRAME_OFF == frameborder) { - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); - if (spacing) { + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + if (border) { nsStyleCoord coord; coord.SetCoordValue(0); - spacing->mBorder.SetTop(coord); - spacing->mBorder.SetRight(coord); - spacing->mBorder.SetBottom(coord); - spacing->mBorder.SetLeft(coord); + border->mBorder.SetTop(coord); + border->mBorder.SetRight(coord); + border->mBorder.SetBottom(coord); + border->mBorder.SetLeft(coord); } } } diff --git a/mozilla/layout/html/content/src/nsHTMLInputElement.cpp b/mozilla/layout/html/content/src/nsHTMLInputElement.cpp index e5741abf8a0..e37d6ec8a45 100644 --- a/mozilla/layout/html/content/src/nsHTMLInputElement.cpp +++ b/mozilla/layout/html/content/src/nsHTMLInputElement.cpp @@ -1323,23 +1323,23 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, nscoord pad = NSIntPixelsToTwips(3, p2t); // add left and right padding around the radio button via css - nsStyleSpacing* spacing = (nsStyleSpacing*) aContext->GetMutableStyleData(eStyleStruct_Spacing); - if (eStyleUnit_Null == spacing->mMargin.GetLeftUnit()) { + nsStyleMargin* margin = (nsStyleMargin*) aContext->GetMutableStyleData(eStyleStruct_Margin); + if (eStyleUnit_Null == margin->mMargin.GetLeftUnit()) { nsStyleCoord left(pad); - spacing->mMargin.SetLeft(left); + margin->mMargin.SetLeft(left); } - if (eStyleUnit_Null == spacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Null == margin->mMargin.GetRightUnit()) { nsStyleCoord right(NSIntPixelsToTwips(5, p2t)); - spacing->mMargin.SetRight(right); + margin->mMargin.SetRight(right); } // add bottom padding if backward mode // XXX why isn't this working? nsCompatibility mode; aPresContext->GetCompatibilityMode(&mode); if (eCompatibility_NavQuirks == mode) { - if (eStyleUnit_Null == spacing->mMargin.GetBottomUnit()) { + if (eStyleUnit_Null == margin->mMargin.GetBottomUnit()) { nsStyleCoord bottom(pad); - spacing->mMargin.SetBottom(bottom); + margin->mMargin.SetBottom(bottom); } } break; diff --git a/mozilla/layout/html/content/src/nsHTMLTableElement.cpp b/mozilla/layout/html/content/src/nsHTMLTableElement.cpp index c6f5dedf16c..686d1b2f09f 100644 --- a/mozilla/layout/html/content/src/nsHTMLTableElement.cpp +++ b/mozilla/layout/html/content/src/nsHTMLTableElement.cpp @@ -1063,13 +1063,13 @@ static void MapTableFrameInto(const nsIHTMLMappedAttributes* aAttributes, nsIMutableStyleContext* aContext, nsIPresContext* aPresContext, - nsStyleSpacing* aSpacing, + nsStyleBorder* aBorder, PRUint8 aBorderStyle) { // set up defaults for (PRInt32 sideX = NS_SIDE_TOP; sideX <= NS_SIDE_LEFT; sideX++) { - if (aSpacing->GetBorderStyle(sideX) == NS_STYLE_BORDER_STYLE_NONE) { - aSpacing->SetBorderStyle(sideX, aBorderStyle); + if (aBorder->GetBorderStyle(sideX) == NS_STYLE_BORDER_STYLE_NONE) { + aBorder->SetBorderStyle(sideX, aBorderStyle); } } @@ -1082,44 +1082,44 @@ MapTableFrameInto(const nsIHTMLMappedAttributes* aAttributes, switch (frameValue.GetIntValue()) { case NS_STYLE_TABLE_FRAME_NONE: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_ABOVE: - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_BELOW: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_HSIDES: - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_LEFT: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_RIGHT: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_FRAME_VSIDES: - aSpacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorder->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); break; // BOX and BORDER are ignored, the caller has already set all the border sides @@ -1151,8 +1151,8 @@ MapTableBorderInto(const nsIHTMLMappedAttributes* aAttributes, } if (borderValue.GetUnit() != eHTMLUnit_Null) { - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); nsStyleTable *tableStyle = (nsStyleTable*) aContext->GetMutableStyleData(eStyleStruct_Table); nsStyleCoord twips; @@ -1183,12 +1183,12 @@ MapTableBorderInto(const nsIHTMLMappedAttributes* aAttributes, } // by default, set all border sides to the specified width - spacing->mBorder.SetTop(twips); - spacing->mBorder.SetRight(twips); - spacing->mBorder.SetBottom(twips); - spacing->mBorder.SetLeft(twips); + border->mBorder.SetTop(twips); + border->mBorder.SetRight(twips); + border->mBorder.SetBottom(twips); + border->mBorder.SetLeft(twips); // then account for the frame attribute - MapTableFrameInto(aAttributes, aContext, aPresContext, spacing, + MapTableFrameInto(aAttributes, aContext, aPresContext, border, aBorderStyle); } } @@ -1219,14 +1219,14 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, aPresContext->GetPixelsToTwips(&p2t); nscoord onePixel = NSIntPixelsToTwips(1, p2t); - nsStyleSpacing* spacingStyle = (nsStyleSpacing*)aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* borderStyleData = (nsStyleBorder*)aContext->GetMutableStyleData(eStyleStruct_Border); nsStyleCoord width; width.SetCoordValue(onePixel); - spacingStyle->mBorder.SetTop(width); - spacingStyle->mBorder.SetLeft(width); - spacingStyle->mBorder.SetBottom(width); - spacingStyle->mBorder.SetRight(width); + borderStyleData->mBorder.SetTop(width); + borderStyleData->mBorder.SetLeft(width); + borderStyleData->mBorder.SetBottom(width); + borderStyleData->mBorder.SetRight(width); nsCompatibility mode; aPresContext->GetCompatibilityMode(&mode); @@ -1235,10 +1235,10 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, // BG_INSET results in a border color based on background colors // used for NavQuirks only... - spacingStyle->SetBorderStyle(NS_SIDE_TOP, borderStyle); - spacingStyle->SetBorderStyle(NS_SIDE_LEFT, borderStyle); - spacingStyle->SetBorderStyle(NS_SIDE_BOTTOM, borderStyle); - spacingStyle->SetBorderStyle(NS_SIDE_RIGHT, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_TOP, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_LEFT, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_BOTTOM, borderStyle); + borderStyleData->SetBorderStyle(NS_SIDE_RIGHT, borderStyle); } } else { // handle attributes for table @@ -1289,8 +1289,10 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, } } - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* borderStyleData = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + nsStyleMargin* marginStyleData = (nsStyleMargin*) + aContext->GetMutableStyleData(eStyleStruct_Margin); // default border style is the Nav4.6 extension which uses the // background color as the basis of the outset border. If the @@ -1312,10 +1314,10 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if ((eHTMLUnit_Color == value.GetUnit()) || (eHTMLUnit_ColorName == value.GetUnit())) { nscolor color = value.GetColorValue(); - spacing->SetBorderColor(0, color); - spacing->SetBorderColor(1, color); - spacing->SetBorderColor(2, color); - spacing->SetBorderColor(3, color); + borderStyleData->SetBorderColor(0, color); + borderStyleData->SetBorderColor(1, color); + borderStyleData->SetBorderColor(2, color); + borderStyleData->SetBorderColor(3, color); borderStyle = NS_STYLE_BORDER_STYLE_OUTSET; // use css outset } @@ -1330,8 +1332,8 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if ((NS_STYLE_TEXT_ALIGN_CENTER == value.GetIntValue()) || (NS_STYLE_TEXT_ALIGN_MOZ_CENTER == value.GetIntValue())) { nsStyleCoord otto(eStyleUnit_Auto); - spacing->mMargin.SetLeft(otto); - spacing->mMargin.SetRight(otto); + marginStyleData->mMargin.SetLeft(otto); + marginStyleData->mMargin.SetRight(otto); } else { nsStyleDisplay* display = (nsStyleDisplay*) @@ -1415,8 +1417,8 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), sp2t); nsStyleCoord hspace(twips); - spacing->mMargin.SetLeft(hspace); - spacing->mMargin.SetRight(hspace); + marginStyleData->mMargin.SetLeft(hspace); + marginStyleData->mMargin.SetRight(hspace); } aAttributes->GetAttribute(nsHTMLAtoms::vspace, value); @@ -1424,8 +1426,8 @@ MapAttributesInto(const nsIHTMLMappedAttributes* aAttributes, if (value.GetUnit() == eHTMLUnit_Pixel) { nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), sp2t); nsStyleCoord vspace(twips); - spacing->mMargin.SetTop(vspace); - spacing->mMargin.SetBottom(vspace); + marginStyleData->mMargin.SetTop(vspace); + marginStyleData->mMargin.SetBottom(vspace); } } diff --git a/mozilla/layout/html/forms/src/nsButtonFrameRenderer.cpp b/mozilla/layout/html/forms/src/nsButtonFrameRenderer.cpp index 789f676b8bf..2333c7b1a3f 100644 --- a/mozilla/layout/html/forms/src/nsButtonFrameRenderer.cpp +++ b/mozilla/layout/html/forms/src/nsButtonFrameRenderer.cpp @@ -144,10 +144,10 @@ nsButtonFrameRenderer::PaintOutlineAndFocusBorders(nsIPresContext* aPresContext, GetButtonOuterFocusRect(aRect, rect); - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mOuterFocusStyle ->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*)mOuterFocusStyle ->GetStyleData(eStyleStruct_Border); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, mFrame, - aDirtyRect, rect, *spacing, mOuterFocusStyle, 0); + aDirtyRect, rect, *border, mOuterFocusStyle, 0); } // ---------- paint the inner focus border ------------- @@ -155,10 +155,10 @@ nsButtonFrameRenderer::PaintOutlineAndFocusBorders(nsIPresContext* aPresContext, GetButtonInnerFocusRect(aRect, rect); - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Border); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, mFrame, - aDirtyRect, rect, *spacing, mInnerFocusStyle, 0); + aDirtyRect, rect, *border, mInnerFocusStyle, 0); } } @@ -186,8 +186,8 @@ nsButtonFrameRenderer::PaintBorderAndBackground(nsIPresContext* aPresContext, // get the styles - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)context->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)context->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)context->GetStyleData(eStyleStruct_Color); @@ -195,10 +195,10 @@ nsButtonFrameRenderer::PaintBorderAndBackground(nsIPresContext* aPresContext, // paint the border and background nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, mFrame, - aDirtyRect, buttonRect, *color, *spacing, 0, 0); + aDirtyRect, buttonRect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, mFrame, - aDirtyRect, buttonRect, *spacing, context, 0); + aDirtyRect, buttonRect, *border, context, 0); } @@ -247,9 +247,9 @@ nsButtonFrameRenderer::GetButtonOuterFocusBorderAndPadding() nsMargin focusBorderAndPadding(0,0,0,0); if (mOuterFocusStyle) { - // get the outer focus border and padding - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mOuterFocusStyle ->GetStyleData(eStyleStruct_Spacing); - if (!spacing->GetBorderPadding(focusBorderAndPadding)) { + nsStyleBorderPadding bPad; + mOuterFocusStyle->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (!bPad.GetBorderPadding(focusBorderAndPadding)) { NS_NOTYETIMPLEMENTED("percentage border"); } } @@ -263,12 +263,13 @@ nsButtonFrameRenderer::GetButtonBorderAndPadding() nsCOMPtr context; mFrame->GetStyleContext(getter_AddRefs(context)); - nsMargin borderAndPadding(0,0,0,0); - const nsStyleSpacing* spacing = (const nsStyleSpacing*)context ->GetStyleData(eStyleStruct_Spacing); - if (!spacing->GetBorderPadding(borderAndPadding)) { + nsMargin innerFocusBorderAndPadding(0,0,0,0); + nsStyleBorderPadding bPad; + context->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (!bPad.GetBorderPadding(innerFocusBorderAndPadding)) { NS_NOTYETIMPLEMENTED("percentage border"); } - return borderAndPadding; + return innerFocusBorderAndPadding; } /** @@ -281,8 +282,8 @@ nsButtonFrameRenderer::GetButtonInnerFocusMargin() if (mInnerFocusStyle) { // get the outer focus border and padding - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Spacing); - spacing->GetMargin(innerFocusMargin); + const nsStyleMargin* margin = (const nsStyleMargin*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Margin); + margin->GetMargin(innerFocusMargin); } return innerFocusMargin; @@ -295,8 +296,9 @@ nsButtonFrameRenderer::GetButtonInnerFocusBorderAndPadding() if (mInnerFocusStyle) { // get the outer focus border and padding - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mInnerFocusStyle ->GetStyleData(eStyleStruct_Spacing); - if (!spacing->GetBorderPadding(innerFocusBorderAndPadding)) { + nsStyleBorderPadding bPad; + mInnerFocusStyle->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + if (!bPad.GetBorderPadding(innerFocusBorderAndPadding)) { NS_NOTYETIMPLEMENTED("percentage border"); } } diff --git a/mozilla/layout/html/forms/src/nsComboboxControlFrame.cpp b/mozilla/layout/html/forms/src/nsComboboxControlFrame.cpp index 4d2f99a8475..abf112bee84 100644 --- a/mozilla/layout/html/forms/src/nsComboboxControlFrame.cpp +++ b/mozilla/layout/html/forms/src/nsComboboxControlFrame.cpp @@ -830,11 +830,8 @@ nsComboboxControlFrame::ReflowItems(nsIPresContext* aPresContext, delete [] str; // get the borderPadding for the display area - const nsStyleSpacing* dspSpacing; - mDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - dspSpacing->CalcBorderPaddingFor(mDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); nscoord frmWidth = maxWidth+dspBorderPadding.left+dspBorderPadding.right+ aReflowState.mComputedBorderPadding.left + aReflowState.mComputedBorderPadding.right; @@ -886,11 +883,8 @@ nsComboboxControlFrame::ReflowCombobox(nsIPresContext * aPresContext, REFLOW_NOISY_MSG3("mCacheSize.height:%d - %d\n", PX(mCacheSize.height), PX((aBorderPadding.top + aBorderPadding.bottom))); // get the border and padding for the DisplayArea (block frame & textframe) - const nsStyleSpacing* dspSpacing; - aDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - dspSpacing->CalcBorderPaddingFor(aDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); // adjust the height if (mCacheSize.height == kSizeNotSet) { @@ -1154,11 +1148,8 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, bailOnWidth, bailOnHeight); if (bailOnWidth) { #ifdef DO_REFLOW_DEBUG // check or size - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - nsMargin borderPadding; - borderPadding.SizeTo(0, 0, 0, 0); - spacing->CalcBorderPaddingFor(this, borderPadding); + nsMargin borderPadding(0, 0, 0, 0); + CalcBorderPadding(borderPadding); UNCONSTRAINED_CHECK(); #endif REFLOW_DEBUG_MSG3("^** Done nsCCF DW: %d DH: %d\n\n", PX(aDesiredSize.width), PX(aDesiredSize.height)); @@ -1199,11 +1190,8 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, // get our border and padding, // XXX - should be the same mComputedBorderPadding? // maybe we should use that? - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - nsMargin borderPadding; - borderPadding.SizeTo(0, 0, 0, 0); - spacing->CalcBorderPaddingFor(this, borderPadding); + nsMargin borderPadding(0, 0, 0, 0); + CalcBorderPadding(borderPadding); // Get the current sizes of the combo box child frames mDisplayFrame->GetRect(displayRect); @@ -1480,18 +1468,12 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, } // Get the border and padding for the dropdown - const nsStyleSpacing* dropSpacing; - mDropdownFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dropSpacing); - nsMargin dropBorderPadding; - dropBorderPadding.SizeTo(0, 0, 0, 0); - dropSpacing->CalcBorderPaddingFor(mDropdownFrame, dropBorderPadding); + nsMargin dropBorderPadding(0, 0, 0, 0); + mDropdownFrame->CalcBorderPadding(dropBorderPadding); // get the borderPadding for the display area - const nsStyleSpacing* dspSpacing; - mDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - dspSpacing->CalcBorderPaddingFor(mDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); // Substract dropdown's borderPadding from the width of the dropdown rect // to get the size of the content area @@ -1571,12 +1553,8 @@ nsComboboxControlFrame::Reflow(nsIPresContext* aPresContext, } // get the borderPadding for the display area - const nsStyleSpacing* dspSpacing; - mDisplayFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)dspSpacing); - nsMargin dspBorderPadding; - dspBorderPadding.SizeTo(0, 0, 0, 0); - - dspSpacing->CalcBorderPaddingFor(mDisplayFrame, dspBorderPadding); + nsMargin dspBorderPadding(0, 0, 0, 0); + mDisplayFrame->CalcBorderPadding(dspBorderPadding); if (NS_UNCONSTRAINEDSIZE == firstPassState.mComputedWidth) { mItemDisplayWidth = aDesiredSize.width - (dspBorderPadding.left + dspBorderPadding.right); diff --git a/mozilla/layout/html/forms/src/nsFieldSetFrame.cpp b/mozilla/layout/html/forms/src/nsFieldSetFrame.cpp index e60fb79664d..51f06b94582 100644 --- a/mozilla/layout/html/forms/src/nsFieldSetFrame.cpp +++ b/mozilla/layout/html/forms/src/nsFieldSetFrame.cpp @@ -163,11 +163,11 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* borderStyle = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); nsMargin border; - if (!spacing->GetBorder(border)) { + if (!borderStyle->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } @@ -181,7 +181,7 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, nsRect rect(0, yoff, mRect.width, mRect.height - yoff); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *borderStyle, 0, 0); if (mLegendFrame) { @@ -198,7 +198,7 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyle, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -212,7 +212,7 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyle, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -226,14 +226,14 @@ nsFieldSetFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyle, mStyleContext, skipSides); aRenderingContext.PopState(clipState); } else { nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *spacing, mStyleContext, skipSides); + aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *borderStyle, mStyleContext, skipSides); } } } @@ -347,10 +347,10 @@ nsFieldSetFrame::Reflow(nsIPresContext* aPresContext, nsMargin legendMargin(0,0,0,0); // reflow the legend only if needed if (mLegendFrame) { - const nsStyleSpacing* legendSpacing; - mLegendFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) legendSpacing); - legendSpacing->GetMargin(legendMargin); + const nsStyleMargin* marginStyle; + mLegendFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) marginStyle); + marginStyle->GetMargin(legendMargin); if (reflowLegend) { nsHTMLReflowState legendReflowState(aPresContext, aReflowState, @@ -482,12 +482,12 @@ nsFieldSetFrame::Reflow(nsIPresContext* aPresContext, } else { // if we don't need to reflow just get the old size mContentFrame->GetRect(contentRect); - const nsStyleSpacing* spacing; - mContentFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); + const nsStyleMargin* marginStyle; + mContentFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) marginStyle); nsMargin m(0,0,0,0); - spacing->GetMargin(m); + marginStyle->GetMargin(m); contentRect.Inflate(m); } } diff --git a/mozilla/layout/html/forms/src/nsFormControlFrame.cpp b/mozilla/layout/html/forms/src/nsFormControlFrame.cpp index 00dd715ab88..9b207814899 100644 --- a/mozilla/layout/html/forms/src/nsFormControlFrame.cpp +++ b/mozilla/layout/html/forms/src/nsFormControlFrame.cpp @@ -925,9 +925,9 @@ nsresult nsFormControlFrame::PaintSpecialBorder(nsIPresContext* aPresContext, if (specialBorderStyle){ // paint the border - const nsStyleSpacing* spacing = (const nsStyleSpacing*)specialBorderStyle ->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*)specialBorderStyle ->GetStyleData(eStyleStruct_Border); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, aFrame, - aDirtyRect, aRect, *spacing, specialBorderStyle, 0); + aDirtyRect, aRect, *border, specialBorderStyle, 0); } } else { diff --git a/mozilla/layout/html/forms/src/nsGfxCheckboxControlFrame.cpp b/mozilla/layout/html/forms/src/nsGfxCheckboxControlFrame.cpp index a0034060f11..00985c130be 100644 --- a/mozilla/layout/html/forms/src/nsGfxCheckboxControlFrame.cpp +++ b/mozilla/layout/html/forms/src/nsGfxCheckboxControlFrame.cpp @@ -268,13 +268,10 @@ nsGfxCheckboxControlFrame::PaintCheckBox(nsIPresContext* aPresContext, float p2t; aPresContext->GetScaledPixelsToTwips(&p2t); - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + nsMargin borderPadding(0,0,0,0); + CalcBorderPadding(borderPadding); nsRect checkRect(0,0, mRect.width, mRect.height); - - nsMargin borderPadding; - spacing->CalcBorderPaddingFor(this, borderPadding); checkRect.Deflate(borderPadding); const nsStyleColor* color = (const nsStyleColor*) @@ -382,8 +379,8 @@ nsGfxCheckboxControlFrame::Paint(nsIPresContext* aPresContext, mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Color); if (myColor->mBackgroundImage.Length() > 0) { - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*) + mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Border); const nsStylePosition* myPosition = (const nsStylePosition*) mCheckButtonFaceStyle->GetStyleData(eStyleStruct_Position); @@ -395,9 +392,9 @@ nsGfxCheckboxControlFrame::Paint(nsIPresContext* aPresContext, nsRect rect(x, y, width, height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *myColor, *mySpacing, 0, 0); + aDirtyRect, rect, *myColor, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mCheckButtonFaceStyle, 0); + aDirtyRect, rect, *myBorder, mCheckButtonFaceStyle, 0); doDefaultPainting = PR_FALSE; } } diff --git a/mozilla/layout/html/forms/src/nsGfxListControlFrame.cpp b/mozilla/layout/html/forms/src/nsGfxListControlFrame.cpp index bd9b14f8f7a..f411b67b25c 100644 --- a/mozilla/layout/html/forms/src/nsGfxListControlFrame.cpp +++ b/mozilla/layout/html/forms/src/nsGfxListControlFrame.cpp @@ -554,11 +554,8 @@ nsGfxListControlFrame::Reflow(nsIPresContext* aPresContext, } else if (targetFrame == firstChildFrame) { nsRect rect; firstChildFrame->GetRect(rect); - const nsStyleSpacing* scrollSpacing; - firstChildFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)scrollSpacing); - nsMargin scrollBorderPadding; - scrollBorderPadding.SizeTo(0, 0, 0, 0); - scrollSpacing->CalcBorderPaddingFor(firstChildFrame, scrollBorderPadding); + nsMargin scrollBorderPadding(0, 0, 0, 0); + firstChildFrame->CalcBorderPadding(scrollBorderPadding); rect.width -= (scrollBorderPadding.left + scrollBorderPadding.right); rect.height -= (scrollBorderPadding.top + scrollBorderPadding.bottom)*2; printf("Inc Pass CW: %d CH: %d\n", rect.width, rect.height); @@ -741,22 +738,19 @@ nsGfxListControlFrame::Reflow(nsIPresContext* aPresContext, // Subtract out the borders nsMargin border; - if (!aReflowState.mStyleSpacing->GetBorder(border)) { + if (!aReflowState.mStyleBorder->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); border.SizeTo(0, 0, 0, 0); } nsMargin padding; - if (!aReflowState.mStyleSpacing->GetPadding(padding)) { + if (!aReflowState.mStylePadding->GetPadding(padding)) { NS_NOTYETIMPLEMENTED("percentage padding"); padding.SizeTo(0, 0, 0, 0); } - const nsStyleSpacing* scrollSpacing; - firstChildFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)scrollSpacing); - nsMargin scrollBorderPadding; - scrollBorderPadding.SizeTo(0, 0, 0, 0); - scrollSpacing->CalcBorderPaddingFor(firstChildFrame, scrollBorderPadding); + nsMargin scrollBorderPadding(0, 0, 0, 0); + firstChildFrame->CalcBorderPadding(scrollBorderPadding); mMaxWidth -= (scrollBorderPadding.left + scrollBorderPadding.right); diff --git a/mozilla/layout/html/forms/src/nsGfxRadioControlFrame.cpp b/mozilla/layout/html/forms/src/nsGfxRadioControlFrame.cpp index 742b5c84c05..d7b593d4064 100644 --- a/mozilla/layout/html/forms/src/nsGfxRadioControlFrame.cpp +++ b/mozilla/layout/html/forms/src/nsGfxRadioControlFrame.cpp @@ -282,8 +282,8 @@ nsGfxRadioControlFrame::PaintRadioButton(nsIPresContext* aPresContext, if (nsnull != mRadioButtonFaceStyle) { const nsStyleColor* myColor = (const nsStyleColor*) mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*) + mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Border); const nsStylePosition* myPosition = (const nsStylePosition*) mRadioButtonFaceStyle->GetStyleData(eStyleStruct_Position); @@ -300,9 +300,9 @@ nsGfxRadioControlFrame::PaintRadioButton(nsIPresContext* aPresContext, nsStyleColor tmpColor = *myColor; tmpColor.mBackgroundColor = myColor->mColor; nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, tmpColor, *mySpacing, 0, 0); + aDirtyRect, rect, tmpColor, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mRadioButtonFaceStyle, 0); + aDirtyRect, rect, *myBorder, mRadioButtonFaceStyle, 0); } } } diff --git a/mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp b/mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp index 32cac471216..5c800f74b8c 100644 --- a/mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp +++ b/mozilla/layout/html/forms/src/nsGfxTextControlFrame.cpp @@ -1022,10 +1022,12 @@ nsGfxTextControlFrame::RedispatchMouseEventToSubDoc(nsIPresContext* aPresContext nsMargin padding; border.SizeTo(0, 0, 0, 0); padding.SizeTo(0, 0, 0, 0); - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - spacing->CalcBorderFor(this, border); - spacing->CalcPaddingFor(this, padding); + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)borderStyle); + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)paddingStyle); + borderStyle->CalcBorderFor(this, border); + paddingStyle->CalcPaddingFor(this, padding); CalcSizeOfSubDocInTwips(border, padding, size, subBounds); event.point.x -= (border.left + padding.left); if (0>event.point.x) { @@ -1343,10 +1345,12 @@ nsGfxTextControlFrame::CreateSubDoc(nsRect *aSizeOfSubdocContainer) border.SizeTo(0, 0, 0, 0); padding.SizeTo(0, 0, 0, 0); // Get the CSS border - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - spacing->CalcBorderFor(this, border); - spacing->CalcPaddingFor(this, padding); + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)borderStyle); + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)paddingStyle); + borderStyle->CalcBorderFor(this, border); + paddingStyle->CalcPaddingFor(this, padding); CalcSizeOfSubDocInTwips(border, padding, size, subBounds); float t2p; mFramePresContext->GetTwipsToPixels(&t2p); @@ -1620,14 +1624,14 @@ nsGfxTextControlFrame::PaintTextControl(nsIPresContext* aPresContext, { nsCompatibility mode; aPresContext->GetCompatibilityMode(&mode); - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*)aStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*)aStyleContext->GetStyleData(eStyleStruct_Border); PRIntn skipSides = 0; nsRect rect(0, 0, mRect.width, mRect.height); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *mySpacing, 0, 0); + aDirtyRect, rect, *color, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, aStyleContext, skipSides); + aDirtyRect, rect, *myBorder, aStyleContext, skipSides); if (!mDocShell) { if (mDisplayFrame) { @@ -1961,10 +1965,10 @@ nsGfxTextControlFrame::CreateDocShell(nsIPresContext* aPresContext, view->SetVisibility(nsViewVisibility_kHide); } - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); + const nsStyleBorder* borderStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)borderStyle); nsMargin border; - spacing->CalcBorderFor(this, border); + borderStyle->CalcBorderFor(this, border); nsCOMPtr widget; view->GetWidget(*getter_AddRefs(widget)); @@ -2091,12 +2095,6 @@ nsGfxTextControlFrame::ReflowNavQuirks(nsIPresContext* aPresContext, nsMargin& aBorder, nsMargin& aPadding) { - nsMargin borderPadding; - borderPadding.SizeTo(0, 0, 0, 0); - // Get the CSS border - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - // This calculates the reflow size // get the css size and let the frame use or override it nsSize styleSize; @@ -2146,9 +2144,10 @@ nsGfxTextControlFrame::ReflowNavQuirks(nsIPresContext* aPresContext, } // In Nav Quirks mode we only add in extra size for padding - nsMargin padding; - padding.SizeTo(0, 0, 0, 0); - spacing->CalcPaddingFor(this, padding); + nsMargin padding(0, 0, 0, 0); + const nsStylePadding* paddingStyle; + GetStyleData(nsStylePadding, (const nsStyleStruct *&)paddingStyle); + paddingStyle->CalcPaddingFor(this, padding); // Check to see if style was responsible // for setting the height or the width @@ -2165,9 +2164,9 @@ nsGfxTextControlFrame::ReflowNavQuirks(nsIPresContext* aPresContext, if (addBorder) { if (CSS_NOTSET != styleSize.width || CSS_NOTSET != styleSize.height) { // css provides width - nsMargin border; - border.SizeTo(0, 0, 0, 0); - spacing->CalcBorderFor(this, border); + nsMargin border(0, 0, 0, 0); + GetStyleData(nsStyleBorder, (const nsStyleStruct *&)borderStyle); + borderStyle->CalcBorderFor(this, border); if (CSS_NOTSET != styleSize.width) { // css provides width aDesiredSize.width += border.left + border.right; } @@ -2456,10 +2455,12 @@ nsGfxTextControlFrame::Reflow(nsIPresContext* aPresContext, nsMargin padding; padding.SizeTo(0, 0, 0, 0); // Get the CSS border - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - spacing->CalcBorderFor(this, border); - spacing->CalcPaddingFor(this, padding); + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)borderStyle); + GetStyleData(eStyleStruct_Padding, (const nsStyleStruct *&)paddingStyle); + borderStyle->CalcBorderFor(this, border); + paddingStyle->CalcPaddingFor(this, padding); // calculate the the desired size for the text control // use the suggested size if it has been set diff --git a/mozilla/layout/html/forms/src/nsGfxTextControlFrame2.cpp b/mozilla/layout/html/forms/src/nsGfxTextControlFrame2.cpp index fcfbbdccea5..e9888445d32 100644 --- a/mozilla/layout/html/forms/src/nsGfxTextControlFrame2.cpp +++ b/mozilla/layout/html/forms/src/nsGfxTextControlFrame2.cpp @@ -2061,10 +2061,12 @@ nsGfxTextControlFrame2::GetPrefSize(nsBoxLayoutState& aState, nsSize& aSize) padding.SizeTo(0, 0, 0, 0); // Get the CSS border - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); - spacing->CalcBorderFor(this, border); - spacing->CalcPaddingFor(this, padding); + const nsStyleBorder* borderStyle; + const nsStylePadding* paddingStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)borderStyle); + GetStyleData(eStyleStruct_Padding, (const nsStyleStruct *&)paddingStyle); + borderStyle->CalcBorderFor(this, border); + paddingStyle->CalcPaddingFor(this, padding); nsresult rv; if (navQuirksMode) { diff --git a/mozilla/layout/html/forms/src/nsHTMLButtonControlFrame.cpp b/mozilla/layout/html/forms/src/nsHTMLButtonControlFrame.cpp index 5fadcbc33b1..070d83764f6 100644 --- a/mozilla/layout/html/forms/src/nsHTMLButtonControlFrame.cpp +++ b/mozilla/layout/html/forms/src/nsHTMLButtonControlFrame.cpp @@ -492,11 +492,11 @@ nsHTMLButtonControlFrame::Paint(nsIPresContext* aPresContext, // but the real problem is the FirstChild (the AreaFrame) // isn't being constrained properly // Bug #17474 - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing); + const nsStyleBorder* borderStyle; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct *&)borderStyle); nsMargin border; border.SizeTo(0, 0, 0, 0); - spacing->CalcBorderFor(this, border); + borderStyle->CalcBorderFor(this, border); nsRect rect; GetRect(rect); diff --git a/mozilla/layout/html/forms/src/nsLabelFrame.cpp b/mozilla/layout/html/forms/src/nsLabelFrame.cpp index 97be07115c5..4f3069bfd38 100644 --- a/mozilla/layout/html/forms/src/nsLabelFrame.cpp +++ b/mozilla/layout/html/forms/src/nsLabelFrame.cpp @@ -589,10 +589,8 @@ nsLabelFrame::Reflow(nsIPresContext* aPresContext, nsSize availSize(aReflowState.availableWidth, aReflowState.availableHeight); // get border and padding - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); - nsMargin borderPadding; - spacing->CalcBorderPaddingFor(this, borderPadding); + nsMargin borderPadding(0,0,0,0); + CalcBorderPadding(borderPadding); if (NS_INTRINSICSIZE != availSize.width) { availSize.width -= borderPadding.left + borderPadding.right; diff --git a/mozilla/layout/html/style/src/nsCSSFrameConstructor.cpp b/mozilla/layout/html/style/src/nsCSSFrameConstructor.cpp index 7175ba23e12..7138c28cd71 100644 --- a/mozilla/layout/html/style/src/nsCSSFrameConstructor.cpp +++ b/mozilla/layout/html/style/src/nsCSSFrameConstructor.cpp @@ -9490,10 +9490,10 @@ ApplyRenderingChangeToTree(nsIPresContext* aPresContext, if (! view) { // if frame has view, will already be invalidated // XXX Instead of calling this we should really be calling // Invalidate on on the nsFrame (which does this) - const nsStyleSpacing* spacing; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + const nsStyleOutline* outline; + aFrame->GetStyleData(eStyleStruct_Outline, (const nsStyleStruct*&)outline); nscoord width; - spacing->GetOutlineWidth(width); + outline->GetOutlineWidth(width); if (width > 0) { invalidRect.Inflate(width, width); } diff --git a/mozilla/layout/html/style/src/nsCSSRendering.cpp b/mozilla/layout/html/style/src/nsCSSRendering.cpp index 88af1ae670c..ae93759c22c 100644 --- a/mozilla/layout/html/style/src/nsCSSRendering.cpp +++ b/mozilla/layout/html/style/src/nsCSSRendering.cpp @@ -740,21 +740,26 @@ nscoord xstart,xwidth,ystart,ywidth; void nsCSSRendering::DrawDashedSides(PRIntn startSide, nsIRenderingContext& aContext, const nsRect& aDirtyRect, - const nsStyleSpacing& aSpacing, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, PRBool aDoOutline, const nsRect& borderOutside, const nsRect& borderInside, PRIntn aSkipSides, nsRect* aGap) { + PRIntn dashLength; nsRect dashRect, currRect; nscoord xstart,xwidth,ystart,ywidth,temp,temp1,adjust; PRBool bSolid = PR_TRUE; float over = 0.0f; -PRUint8 style = aDoOutline?aSpacing.GetOutlineStyle():aSpacing.GetBorderStyle(startSide); PRBool skippedSide = PR_FALSE; + NS_ASSERTION((aDoOutline && aOutlineStyle) || (!aDoOutline && aBorderStyle), "null params not allowed"); + PRUint8 style = aDoOutline + ? aOutlineStyle->GetOutlineStyle() + : aBorderStyle->GetBorderStyle(startSide); // find out were x and y start if(aDirtyRect.x > borderInside.x) { @@ -777,7 +782,9 @@ PRBool skippedSide = PR_FALSE; for (PRIntn whichSide = startSide; whichSide < 4; whichSide++) { PRUint8 prevStyle = style; - style = aDoOutline?aSpacing.GetOutlineStyle():aSpacing.GetBorderStyle(whichSide); + style = aDoOutline + ? aOutlineStyle->GetOutlineStyle() + : aBorderStyle->GetBorderStyle(whichSide); if ((1<GetOutlineColor(sideColor); } else { - if (!aSpacing.GetBorderColor(whichSide, sideColor)) { + if (!aBorderStyle->GetBorderColor(whichSide, sideColor)) { continue; // side is transparent } } @@ -1488,7 +1495,7 @@ void nsCSSRendering::PaintBorder(nsIPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap, @@ -1569,7 +1576,7 @@ void nsCSSRendering::PaintBorder(nsIPresContext* aPresContext, // check for any corner that is rounded for(i=0;i<4;i++){ if(borderRadii[i] > 0){ - PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aBorderStyle,aStyleContext,aSkipSides,borderRadii,aGap,PR_FALSE); + PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,&aBorderStyle,nsnull,aStyleContext,aSkipSides,borderRadii,aGap,PR_FALSE); return; } } @@ -1600,7 +1607,7 @@ void nsCSSRendering::PaintBorder(nsIPresContext* aPresContext, } } if (cnt < 4) { - DrawDashedSides(cnt, aRenderingContext,aDirtyRect,aBorderStyle, PR_FALSE, + DrawDashedSides(cnt, aRenderingContext,aDirtyRect,&aBorderStyle,nsnull, PR_FALSE, inside, outside, aSkipSides, aGap); } @@ -1670,7 +1677,8 @@ void nsCSSRendering::PaintOutline(nsIPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, + const nsStyleOutline& aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap) @@ -1682,7 +1690,7 @@ const nsStyleColor* bgColor = nsStyleUtil::FindNonTransparentBackground(aStyleCo nscoord width; - aBorderStyle.GetOutlineWidth(width); + aOutlineStyle.GetOutlineWidth(width); if (0 == width) { // Empty outline @@ -1690,10 +1698,10 @@ nscoord width; } // get the radius for our border - aBorderStyle.mOutlineRadius.GetTop(bordStyleRadius[0]); //topleft - aBorderStyle.mOutlineRadius.GetRight(bordStyleRadius[1]); //topright - aBorderStyle.mOutlineRadius.GetBottom(bordStyleRadius[2]); //bottomright - aBorderStyle.mOutlineRadius.GetLeft(bordStyleRadius[3]); //bottomleft + aOutlineStyle.mOutlineRadius.GetTop(bordStyleRadius[0]); //topleft + aOutlineStyle.mOutlineRadius.GetRight(bordStyleRadius[1]); //topright + aOutlineStyle.mOutlineRadius.GetBottom(bordStyleRadius[2]); //bottomright + aOutlineStyle.mOutlineRadius.GetLeft(bordStyleRadius[3]); //bottomleft for(i=0;i<4;i++) { borderRadii[i] = 0; @@ -1744,18 +1752,18 @@ nscoord width; // rounded version of the border for(i=0;i<4;i++){ if(borderRadii[i] > 0){ - PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aBorderStyle,aStyleContext,aSkipSides,borderRadii,aGap,PR_TRUE); + PaintRoundedBorder(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,nsnull,&aOutlineStyle,aStyleContext,aSkipSides,borderRadii,aGap,PR_TRUE); aRenderingContext.PopState(clipState); return; } } - PRUint8 outlineStyle = aBorderStyle.GetOutlineStyle(); + PRUint8 outlineStyle = aOutlineStyle.GetOutlineStyle(); //see if any sides are dotted or dashed if ((outlineStyle == NS_STYLE_BORDER_STYLE_DOTTED) || (outlineStyle == NS_STYLE_BORDER_STYLE_DASHED)) { - DrawDashedSides(0, aRenderingContext, aDirtyRect, aBorderStyle, PR_TRUE, + DrawDashedSides(0, aRenderingContext, aDirtyRect, nsnull, &aOutlineStyle, PR_TRUE, outside, inside, aSkipSides, aGap); aRenderingContext.PopState(clipState); return; @@ -1771,7 +1779,7 @@ nscoord width; nscolor outlineColor; - if (aBorderStyle.GetOutlineColor(outlineColor)) { + if (aOutlineStyle.GetOutlineColor(outlineColor)) { DrawSide(aRenderingContext, NS_SIDE_BOTTOM, outlineStyle, outlineColor, @@ -2070,7 +2078,7 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aSpacing, + const nsStyleBorder& aBorder, nscoord aDX, nscoord aDY) { @@ -2125,7 +2133,7 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, nsRect paddingArea(aBorderArea); nsMargin border; - if (!aSpacing.GetBorder(border)) { + if (!aBorder.GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } paddingArea.Deflate(border); @@ -2483,10 +2491,10 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, // is rendered over the 'border' 'padding' and 'content' areas if (!transparentBG) { // get the radius for our border - aSpacing.mBorderRadius.GetTop(bordStyleRadius[0]); //topleft - aSpacing.mBorderRadius.GetRight(bordStyleRadius[1]); //topright - aSpacing.mBorderRadius.GetBottom(bordStyleRadius[2]); //bottomright - aSpacing.mBorderRadius.GetLeft(bordStyleRadius[3]); //bottomleft + aBorder.mBorderRadius.GetTop(bordStyleRadius[0]); //topleft + aBorder.mBorderRadius.GetRight(bordStyleRadius[1]); //topright + aBorder.mBorderRadius.GetBottom(bordStyleRadius[2]); //bottomright + aBorder.mBorderRadius.GetLeft(bordStyleRadius[3]); //bottomleft for(i=0;i<4;i++) { borderRadii[i] = 0; @@ -2509,7 +2517,7 @@ nsCSSRendering::PaintBackground(nsIPresContext* aPresContext, // rounded version of the border for(i=0;i<4;i++){ if (borderRadii[i] > 0){ - PaintRoundedBackground(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aColor,aSpacing,aDX,aDY,borderRadii); + PaintRoundedBackground(aPresContext,aRenderingContext,aForFrame,aDirtyRect,aBorderArea,aColor,aDX,aDY,borderRadii); return; } } @@ -2563,7 +2571,6 @@ nsCSSRendering::PaintRoundedBackground(nsIPresContext* aPresContext, const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aSpacing, nscoord aDX, nscoord aDY, PRInt16 aTheRadius[4]) @@ -2652,7 +2659,8 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, PRInt16 aBorderRadius[4], @@ -2670,16 +2678,16 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, nscoord twipsPerPixel,qtwips; float p2t; - + NS_ASSERTION((aIsOutline && aOutlineStyle) || (!aIsOutline && aBorderStyle), "null params not allowed"); if (!aIsOutline) { - aBorderStyle.CalcBorderFor(aForFrame, border); + aBorderStyle->CalcBorderFor(aForFrame, border); if ((0 == border.left) && (0 == border.right) && (0 == border.top) && (0 == border.bottom)) { return; } } else { nscoord width; - if (!aBorderStyle.GetOutlineWidth(width)) { + if (!aOutlineStyle->GetOutlineWidth(width)) { return; } border.left = width; @@ -2720,7 +2728,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr2.mAnc2.x, Icr2.mAnc2.y); thePath[np++].MoveTo(Icr2.mCon.x, Icr2.mCon.y); thePath[np++].MoveTo(Icr2.mAnc1.x, Icr2.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_TOP,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_TOP,border,qtwips, aIsOutline); } // RIGHT LINE ---------------------------------------------------------------- LR.MidPointDivide(&cr2,&cr3); @@ -2740,7 +2748,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr4.mAnc2.x,Icr4.mAnc2.y); thePath[np++].MoveTo(Icr4.mCon.x, Icr4.mCon.y); thePath[np++].MoveTo(Icr4.mAnc1.x,Icr4.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_RIGHT,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_RIGHT,border,qtwips, aIsOutline); } // bottom line ---------------------------------------------------------------- @@ -2761,7 +2769,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr3.mAnc2.x, Icr3.mAnc2.y); thePath[np++].MoveTo(Icr3.mCon.x, Icr3.mCon.y); thePath[np++].MoveTo(Icr3.mAnc1.x, Icr3.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_BOTTOM,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_BOTTOM,border,qtwips, aIsOutline); } // left line ---------------------------------------------------------------- if(0==border.left) @@ -2782,7 +2790,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, thePath[np++].MoveTo(Icr4.mCon.x, Icr4.mCon.y); thePath[np++].MoveTo(Icr4.mAnc1.x, Icr4.mAnc1.y); - RenderSide(thePath,aRenderingContext,aBorderStyle,aStyleContext,NS_SIDE_LEFT,border,qtwips, aIsOutline); + RenderSide(thePath,aRenderingContext,aBorderStyle,aOutlineStyle,aStyleContext,NS_SIDE_LEFT,border,qtwips, aIsOutline); } @@ -2792,7 +2800,7 @@ nsCSSRendering::PaintRoundedBorder(nsIPresContext* aPresContext, */ void nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderingContext, - const nsStyleSpacing& aBorderStyle,nsIStyleContext* aStyleContext, + const nsStyleBorder* aBorderStyle,const nsStyleOutline* aOutlineStyle,nsIStyleContext* aStyleContext, PRUint8 aSide,nsMargin &aBorThick,nscoord aTwipsPerPixel, PRBool aIsOutline) { @@ -2803,11 +2811,12 @@ nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderin PRInt8 border_Style; PRInt16 thickness; + NS_ASSERTION((aIsOutline && aOutlineStyle) || (!aIsOutline && aBorderStyle), "null params not allowed"); // set the style information if (!aIsOutline) { - aBorderStyle.GetBorderColor(aSide,sideColor); + aBorderStyle->GetBorderColor(aSide,sideColor); } else { - aBorderStyle.GetOutlineColor(sideColor); + aOutlineStyle->GetOutlineColor(sideColor); } aRenderingContext.SetColor ( sideColor ); @@ -2838,16 +2847,15 @@ nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderin } else { if (!aIsOutline) { - border_Style = aBorderStyle.GetBorderStyle(aSide); + border_Style = aBorderStyle->GetBorderStyle(aSide); } else { - border_Style = aBorderStyle.GetOutlineStyle(); + border_Style = aOutlineStyle->GetOutlineStyle(); } switch (border_Style){ case NS_STYLE_BORDER_STYLE_OUTSET: case NS_STYLE_BORDER_STYLE_INSET: { const nsStyleColor* bgColor = nsStyleUtil::FindNonTransparentBackground(aStyleContext); - aBorderStyle.GetBorderColor(aSide,sideColor); aRenderingContext.SetColor ( MakeBevelColor (aSide, border_Style, bgColor->mBackgroundColor,sideColor, PR_TRUE)); } case NS_STYLE_BORDER_STYLE_DOTTED: @@ -2892,7 +2900,6 @@ nsCSSRendering::RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderin case NS_STYLE_BORDER_STYLE_GROOVE: { const nsStyleColor* bgColor = nsStyleUtil::FindNonTransparentBackground(aStyleContext); - aBorderStyle.GetBorderColor(aSide,sideColor); aRenderingContext.SetColor ( MakeBevelColor (aSide, border_Style, bgColor->mBackgroundColor,sideColor, PR_TRUE)); polypath[0].x = NSToCoordRound(aPoints[0].x); diff --git a/mozilla/layout/html/style/src/nsCSSRendering.h b/mozilla/layout/html/style/src/nsCSSRendering.h index 91d473640b7..68c7a21e2d3 100644 --- a/mozilla/layout/html/style/src/nsCSSRendering.h +++ b/mozilla/layout/html/style/src/nsCSSRendering.h @@ -41,7 +41,7 @@ public: nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap = 0, @@ -61,7 +61,8 @@ public: nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder& aBorderStyle, + const nsStyleOutline& aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, nsRect* aGap = 0); @@ -101,7 +102,7 @@ public: const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aStyle, + const nsStyleBorder& aBorder, nscoord aDX, nscoord aDY); @@ -118,7 +119,8 @@ public: static void DrawDashedSides(PRIntn startSide, nsIRenderingContext& aContext, const nsRect& aDirtyRect, - const nsStyleSpacing& aSpacing, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, PRBool aDoOutline, const nsRect& borderOutside, const nsRect& borderInside, @@ -147,7 +149,8 @@ protected: nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, - const nsStyleSpacing& aBorderStyle, + const nsStyleBorder* aBorderStyle, + const nsStyleOutline* aOutlineStyle, nsIStyleContext* aStyleContext, PRIntn aSkipSides, PRInt16 aBorderRadius[4],nsRect* aGap = 0, @@ -155,7 +158,7 @@ protected: static void RenderSide(nsFloatPoint aPoints[],nsIRenderingContext& aRenderingContext, - const nsStyleSpacing& aBorderStyle,nsIStyleContext* aStyleContext, + const nsStyleBorder* aBorderStyle,const nsStyleOutline* aOutlineStyle,nsIStyleContext* aStyleContext, PRUint8 aSide,nsMargin &aBorThick,nscoord aTwipsPerPixel, PRBool aIsOutline=PR_FALSE); @@ -165,7 +168,6 @@ protected: const nsRect& aDirtyRect, const nsRect& aBorderArea, const nsStyleColor& aColor, - const nsStyleSpacing& aStyle, nscoord aDX, nscoord aDY, PRInt16 aTheRadius[4]); diff --git a/mozilla/layout/html/style/src/nsCSSStyleRule.cpp b/mozilla/layout/html/style/src/nsCSSStyleRule.cpp index 080ad738b15..9027baeb677 100644 --- a/mozilla/layout/html/style/src/nsCSSStyleRule.cpp +++ b/mozilla/layout/html/style/src/nsCSSStyleRule.cpp @@ -2253,33 +2253,41 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nsCSSMargin* ourMargin; if (NS_OK == aDeclaration->GetData(kCSSMarginSID, (nsCSSStruct**)&ourMargin)) { if (nsnull != ourMargin) { - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*)aContext->GetMutableStyleData(eStyleStruct_Margin); + nsStylePadding* padding = (nsStylePadding*)aContext->GetMutableStyleData(eStyleStruct_Padding); + nsStyleBorder* border = (nsStyleBorder*)aContext->GetMutableStyleData(eStyleStruct_Border); + nsStyleOutline* outline = (nsStyleOutline*)aContext->GetMutableStyleData(eStyleStruct_Outline); - const nsStyleSpacing* parentSpacing = spacing; + const nsStyleMargin* parentMargin = margin; + const nsStylePadding* parentPadding = padding; + const nsStyleBorder* parentBorder = border; + const nsStyleOutline* parentOutline = outline; if (nsnull != aParentContext) { - parentSpacing = (const nsStyleSpacing*)aParentContext->GetStyleData(eStyleStruct_Spacing); + parentMargin = (const nsStyleMargin*)aParentContext->GetStyleData(eStyleStruct_Margin); + parentPadding = (const nsStylePadding*)aParentContext->GetStyleData(eStyleStruct_Padding); + parentBorder = (const nsStyleBorder*)aParentContext->GetStyleData(eStyleStruct_Border); + parentOutline = (const nsStyleOutline*)aParentContext->GetStyleData(eStyleStruct_Outline); } // margin: length, percent, auto, inherit if (nsnull != ourMargin->mMargin) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mMargin.GetLeft(parentCoord); + parentMargin->mMargin.GetLeft(parentCoord); if (SetCoord(ourMargin->mMargin->mLeft, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetLeft(coord); + margin->mMargin.SetLeft(coord); } - parentSpacing->mMargin.GetTop(parentCoord); + parentMargin->mMargin.GetTop(parentCoord); if (SetCoord(ourMargin->mMargin->mTop, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetTop(coord); + margin->mMargin.SetTop(coord); } - parentSpacing->mMargin.GetRight(parentCoord); + parentMargin->mMargin.GetRight(parentCoord); if (SetCoord(ourMargin->mMargin->mRight, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetRight(coord); + margin->mMargin.SetRight(coord); } - parentSpacing->mMargin.GetBottom(parentCoord); + parentMargin->mMargin.GetBottom(parentCoord); if (SetCoord(ourMargin->mMargin->mBottom, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetBottom(coord); + margin->mMargin.SetBottom(coord); } } @@ -2287,21 +2295,21 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mPadding) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mPadding.GetLeft(parentCoord); + parentPadding->mPadding.GetLeft(parentCoord); if (SetCoord(ourMargin->mPadding->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetLeft(coord); + padding->mPadding.SetLeft(coord); } - parentSpacing->mPadding.GetTop(parentCoord); + parentPadding->mPadding.GetTop(parentCoord); if (SetCoord(ourMargin->mPadding->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetTop(coord); + padding->mPadding.SetTop(coord); } - parentSpacing->mPadding.GetRight(parentCoord); + parentPadding->mPadding.GetRight(parentCoord); if (SetCoord(ourMargin->mPadding->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetRight(coord); + padding->mPadding.SetRight(coord); } - parentSpacing->mPadding.GetBottom(parentCoord); + parentPadding->mPadding.GetBottom(parentCoord); if (SetCoord(ourMargin->mPadding->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetBottom(coord); + padding->mPadding.SetBottom(coord); } } @@ -2310,31 +2318,31 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nsStyleCoord coord; nsStyleCoord parentCoord; if (SetCoord(ourMargin->mBorderWidth->mLeft, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetLeft(coord); + border->mBorder.SetLeft(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mLeft.GetUnit()) { - spacing->mBorder.SetLeft(parentSpacing->mBorder.GetLeft(coord)); + border->mBorder.SetLeft(parentBorder->mBorder.GetLeft(coord)); } if (SetCoord(ourMargin->mBorderWidth->mTop, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetTop(coord); + border->mBorder.SetTop(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mTop.GetUnit()) { - spacing->mBorder.SetTop(parentSpacing->mBorder.GetTop(coord)); + border->mBorder.SetTop(parentBorder->mBorder.GetTop(coord)); } if (SetCoord(ourMargin->mBorderWidth->mRight, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetRight(coord); + border->mBorder.SetRight(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mRight.GetUnit()) { - spacing->mBorder.SetRight(parentSpacing->mBorder.GetRight(coord)); + border->mBorder.SetRight(parentBorder->mBorder.GetRight(coord)); } if (SetCoord(ourMargin->mBorderWidth->mBottom, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetBottom(coord); + border->mBorder.SetBottom(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mBottom.GetUnit()) { - spacing->mBorder.SetBottom(parentSpacing->mBorder.GetBottom(coord)); + border->mBorder.SetBottom(parentBorder->mBorder.GetBottom(coord)); } } @@ -2342,43 +2350,43 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mBorderStyle) { nsCSSRect* ourStyle = ourMargin->mBorderStyle; if (eCSSUnit_Enumerated == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, ourStyle->mTop.GetIntValue()); + border->SetBorderStyle(NS_SIDE_TOP, ourStyle->mTop.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, parentSpacing->GetBorderStyle(NS_SIDE_TOP)); + border->SetBorderStyle(NS_SIDE_TOP, parentBorder->GetBorderStyle(NS_SIDE_TOP)); } if (eCSSUnit_Enumerated == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, ourStyle->mRight.GetIntValue()); + border->SetBorderStyle(NS_SIDE_RIGHT, ourStyle->mRight.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, parentSpacing->GetBorderStyle(NS_SIDE_RIGHT)); + border->SetBorderStyle(NS_SIDE_RIGHT, parentBorder->GetBorderStyle(NS_SIDE_RIGHT)); } if (eCSSUnit_Enumerated == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, ourStyle->mBottom.GetIntValue()); + border->SetBorderStyle(NS_SIDE_BOTTOM, ourStyle->mBottom.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, parentSpacing->GetBorderStyle(NS_SIDE_BOTTOM)); + border->SetBorderStyle(NS_SIDE_BOTTOM, parentBorder->GetBorderStyle(NS_SIDE_BOTTOM)); } if (eCSSUnit_Enumerated == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, ourStyle->mLeft.GetIntValue()); + border->SetBorderStyle(NS_SIDE_LEFT, ourStyle->mLeft.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, parentSpacing->GetBorderStyle(NS_SIDE_LEFT)); + border->SetBorderStyle(NS_SIDE_LEFT, parentBorder->GetBorderStyle(NS_SIDE_LEFT)); } } @@ -2389,63 +2397,63 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nscolor unused = NS_RGB(0,0,0); if (eCSSUnit_Inherit == ourBorderColor->mTop.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_TOP, borderColor)) { - spacing->SetBorderColor(NS_SIDE_TOP, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_TOP, borderColor)) { + border->SetBorderColor(NS_SIDE_TOP, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_TOP); + border->SetBorderTransparent(NS_SIDE_TOP); } } else if (SetColor(ourBorderColor->mTop, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_TOP, borderColor); + border->SetBorderColor(NS_SIDE_TOP, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mTop.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_TOP); + border->SetBorderTransparent(NS_SIDE_TOP); } if (eCSSUnit_Inherit == ourBorderColor->mRight.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_RIGHT, borderColor)) { - spacing->SetBorderColor(NS_SIDE_RIGHT, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_RIGHT, borderColor)) { + border->SetBorderColor(NS_SIDE_RIGHT, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_RIGHT); + border->SetBorderTransparent(NS_SIDE_RIGHT); } } else if (SetColor(ourBorderColor->mRight, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_RIGHT, borderColor); + border->SetBorderColor(NS_SIDE_RIGHT, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mRight.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_RIGHT); + border->SetBorderTransparent(NS_SIDE_RIGHT); } if (eCSSUnit_Inherit == ourBorderColor->mBottom.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_BOTTOM, borderColor)) { - spacing->SetBorderColor(NS_SIDE_BOTTOM, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_BOTTOM, borderColor)) { + border->SetBorderColor(NS_SIDE_BOTTOM, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_BOTTOM); + border->SetBorderTransparent(NS_SIDE_BOTTOM); } } else if (SetColor(ourBorderColor->mBottom, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_BOTTOM, borderColor); + border->SetBorderColor(NS_SIDE_BOTTOM, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mBottom.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_BOTTOM); + border->SetBorderTransparent(NS_SIDE_BOTTOM); } if (eCSSUnit_Inherit == ourBorderColor->mLeft.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_LEFT, borderColor)) { - spacing->SetBorderColor(NS_SIDE_LEFT, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_LEFT, borderColor)) { + border->SetBorderColor(NS_SIDE_LEFT, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_LEFT); + border->SetBorderTransparent(NS_SIDE_LEFT); } } else if (SetColor(ourBorderColor->mLeft, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_LEFT, borderColor); + border->SetBorderColor(NS_SIDE_LEFT, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mLeft.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_LEFT); + border->SetBorderTransparent(NS_SIDE_LEFT); } } @@ -2453,21 +2461,21 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mBorderRadius) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mBorderRadius.GetLeft(parentCoord); + parentBorder->mBorderRadius.GetLeft(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetLeft(coord); + border->mBorderRadius.SetLeft(coord); } - parentSpacing->mBorderRadius.GetTop(parentCoord); + parentBorder->mBorderRadius.GetTop(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetTop(coord); + border->mBorderRadius.SetTop(coord); } - parentSpacing->mBorderRadius.GetRight(parentCoord); + parentBorder->mBorderRadius.GetRight(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetRight(coord); + border->mBorderRadius.SetRight(coord); } - parentSpacing->mBorderRadius.GetBottom(parentCoord); + parentBorder->mBorderRadius.GetBottom(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetBottom(coord); + border->mBorderRadius.SetBottom(coord); } } @@ -2475,26 +2483,26 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mOutlineRadius) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mOutlineRadius.GetLeft(parentCoord); + parentOutline->mOutlineRadius.GetLeft(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetLeft(coord); + outline->mOutlineRadius.SetLeft(coord); } - parentSpacing->mOutlineRadius.GetTop(parentCoord); + parentOutline->mOutlineRadius.GetTop(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetTop(coord); + outline->mOutlineRadius.SetTop(coord); } - parentSpacing->mOutlineRadius.GetRight(parentCoord); + parentOutline->mOutlineRadius.GetRight(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetRight(coord); + outline->mOutlineRadius.SetRight(coord); } - parentSpacing->mOutlineRadius.GetBottom(parentCoord); + parentOutline->mOutlineRadius.GetBottom(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetBottom(coord); + outline->mOutlineRadius.SetBottom(coord); } } // outline-width: length, enum, inherit - if (! SetCoord(ourMargin->mOutlineWidth, spacing->mOutlineWidth, parentSpacing->mOutlineWidth, + if (! SetCoord(ourMargin->mOutlineWidth, outline->mOutlineWidth, parentOutline->mOutlineWidth, SETCOORD_LEH, aFont->mFont, aPresContext)) { } @@ -2502,37 +2510,37 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nscolor outlineColor; nscolor unused = NS_RGB(0,0,0); if (eCSSUnit_Inherit == ourMargin->mOutlineColor.GetUnit()) { - if (parentSpacing->GetOutlineColor(outlineColor)) { - spacing->SetOutlineColor(outlineColor); + if (parentOutline->GetOutlineColor(outlineColor)) { + outline->SetOutlineColor(outlineColor); } else { - spacing->SetOutlineInvert(); + outline->SetOutlineInvert(); } } else if (SetColor(ourMargin->mOutlineColor, unused, aPresContext, outlineColor)) { - spacing->SetOutlineColor(outlineColor); + outline->SetOutlineColor(outlineColor); } else if (eCSSUnit_Enumerated == ourMargin->mOutlineColor.GetUnit()) { - spacing->SetOutlineInvert(); + outline->SetOutlineInvert(); } // outline-style: enum, none, inherit if (eCSSUnit_Enumerated == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(ourMargin->mOutlineStyle.GetIntValue()); + outline->SetOutlineStyle(ourMargin->mOutlineStyle.GetIntValue()); } else if (eCSSUnit_None == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(NS_STYLE_BORDER_STYLE_NONE); + outline->SetOutlineStyle(NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(parentSpacing->GetOutlineStyle()); + outline->SetOutlineStyle(parentOutline->GetOutlineStyle()); } // float-edge: enum, inherit if (eCSSUnit_Enumerated == ourMargin->mFloatEdge.GetUnit()) { - spacing->mFloatEdge = ourMargin->mFloatEdge.GetIntValue(); + border->mFloatEdge = ourMargin->mFloatEdge.GetIntValue(); } else if (eCSSUnit_Inherit == ourMargin->mFloatEdge.GetUnit()) { - spacing->mFloatEdge = parentSpacing->mFloatEdge; + border->mFloatEdge = parentBorder->mFloatEdge; } } } diff --git a/mozilla/layout/html/style/src/nsComputedDOMStyle.cpp b/mozilla/layout/html/style/src/nsComputedDOMStyle.cpp index 102170bf8b3..98898280bef 100644 --- a/mozilla/layout/html/style/src/nsComputedDOMStyle.cpp +++ b/mozilla/layout/html/style/src/nsComputedDOMStyle.cpp @@ -844,15 +844,15 @@ nsComputedDOMStyle::GetMargin(nsAWritableString& aMargin) nsresult GetMargins(nsIFrame *aFrame, nscoord& left, nscoord& top, nscoord& right, nscoord& bottom) { - const nsStyleSpacing* spacing; + const nsStyleBorder* border; nsStyleCoord coord; - frame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); + frame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + if (border) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); } } } @@ -1267,31 +1267,33 @@ nsComputedDOMStyle::GetAbsoluteFrameRect(nsIFrame *aFrame, nsRect& aRect) } // For the origin, add in the border for the frame - const nsStyleSpacing* spacing; + const nsStyleBorder* border; + const nsStylePadding* padding; nsStyleCoord coord; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); - aRect.width -= spacing->mBorder.GetLeft(coord).GetCoordValue(); - //aRect.width -= spacing->mMargin.GetLeft(coord).GetCoordValue(); - aRect.width -= spacing->mPadding.GetLeft(coord).GetCoordValue(); + aFrame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + aFrame->GetStyleData(eStyleStruct_Padding, (const nsStyleStruct*&)padding); + if (border && padding) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); + aRect.width -= border->mBorder.GetLeft(coord).GetCoordValue(); + //aRect.width -= margin->mMargin.GetLeft(coord).GetCoordValue(); + aRect.width -= padding->mPadding.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); - aRect.height -= spacing->mBorder.GetTop(coord).GetCoordValue(); - //aRect.height -= spacing->mMargin.GetTop(coord).GetCoordValue(); - aRect.height -= spacing->mPadding.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); + aRect.height -= border->mBorder.GetTop(coord).GetCoordValue(); + //aRect.height -= margin->mMargin.GetTop(coord).GetCoordValue(); + aRect.height -= padding->mPadding.GetTop(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetRightUnit()) { - aRect.width -= spacing->mBorder.GetRight(coord).GetCoordValue(); - //aRect.width -= spacing->mMargin.GetRight(coord).GetCoordValue(); - aRect.width -= spacing->mPadding.GetRight(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetRightUnit()) { + aRect.width -= border->mBorder.GetRight(coord).GetCoordValue(); + //aRect.width -= margin->mMargin.GetRight(coord).GetCoordValue(); + aRect.width -= padding->mPadding.GetRight(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetBottomUnit()) { - aRect.height -= spacing->mBorder.GetBottom(coord).GetCoordValue(); - //aRect.height -= spacing->mMargin.GetBottom(coord).GetCoordValue(); - aRect.height -= spacing->mPadding.GetBottom(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetBottomUnit()) { + aRect.height -= border->mBorder.GetBottom(coord).GetCoordValue(); + //aRect.height -= margin->mMargin.GetBottom(coord).GetCoordValue(); + aRect.height -= padding->mPadding.GetBottom(coord).GetCoordValue(); } } diff --git a/mozilla/layout/html/style/src/nsHTMLCSSStyleSheet.cpp b/mozilla/layout/html/style/src/nsHTMLCSSStyleSheet.cpp index d4aba054254..0e501fa570f 100644 --- a/mozilla/layout/html/style/src/nsHTMLCSSStyleSheet.cpp +++ b/mozilla/layout/html/style/src/nsHTMLCSSStyleSheet.cpp @@ -132,13 +132,13 @@ CSSFirstLineRule::MapStyleInto(nsIMutableStyleContext* aContext, parentContext = aContext->GetParent(); // Disable border - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); - if (spacing) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + if (border) { + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); } // Undo any change made to "direction" diff --git a/mozilla/layout/html/table/src/nsTableBorderCollapser.cpp b/mozilla/layout/html/table/src/nsTableBorderCollapser.cpp index ca68afcfe40..507be889da2 100644 --- a/mozilla/layout/html/table/src/nsTableBorderCollapser.cpp +++ b/mozilla/layout/html/table/src/nsTableBorderCollapser.cpp @@ -187,19 +187,19 @@ void nsTableBorderCollapser::ComputeLeftBorderForEdgeAt(nsIPresContext* aPresCon nsVoidArray styles; // styles are added to the array in the order least dominant -> most dominant // 1. table - const nsStyleSpacing *spacing; - mTableFrame.GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + const nsStyleBorder *borderStyleData; + mTableFrame.GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 2. colgroup nsTableColFrame* colFrame; mTableFrame.GetColumnFrame(aColIndex, colFrame); nsIFrame* colGroupFrame; colFrame->GetParent(&colGroupFrame); - colGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 3. col - colFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 4. rowgroup nsTableCellFrame* cellFrame = mTableFrame.GetCellInfoAt(aRowIndex, aColIndex); nsRect rowRect(0,0,0,0); @@ -209,14 +209,14 @@ void nsTableBorderCollapser::ComputeLeftBorderForEdgeAt(nsIPresContext* aPresCon rowFrame->GetRect(rowRect); nsIFrame* rowGroupFrame; rowFrame->GetParent(&rowGroupFrame); - rowGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 5. row - rowFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 6. cell (need to do something smart for rowspanner with row frame) - cellFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + cellFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } ComputeBorderSegment(NS_SIDE_LEFT, &styles, *border, PR_FALSE); // now give half the computed border to the table segment, and half to the cell @@ -293,21 +293,21 @@ void nsTableBorderCollapser::ComputeRightBorderForEdgeAt(nsIPresContext* aPresCo } } } - const nsStyleSpacing *spacing; + const nsStyleBorder *borderStyleData; if (!rightNeighborFrame) { // if rightNeighborFrame is null, our right neighbor is the table - mTableFrame.GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + mTableFrame.GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } // 2. colgroup //XXX: need to test if we're really on a colgroup border nsTableColFrame* colFrame = mTableFrame.GetColFrame(aColIndex); nsIFrame* colGroupFrame; colFrame->GetParent(&colGroupFrame); - colGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 3. col - colFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 4. rowgroup nsTableCellFrame* cellFrame = cellMap->GetCellInfoAt(aRowIndex, aColIndex); nsRect rowRect(0,0,0,0); @@ -319,20 +319,20 @@ void nsTableBorderCollapser::ComputeRightBorderForEdgeAt(nsIPresContext* aPresCo rowFrame->GetParent(&rowGroupFrame); if (!rightNeighborFrame) { // if rightNeighborFrame is null, our right neighbor is the table so we include the rowgroup and row - rowGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 5. row - rowFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } // 6. cell (need to do something smart for rowspanner with row frame) - cellFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + cellFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } // 7. left edge of rightNeighborCell, if there is one if (rightNeighborFrame) { - rightNeighborFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rightNeighborFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } ComputeBorderSegment(NS_SIDE_RIGHT, &styles, border, (nsnull != rightNeighborFrame)); // now give half the computed border to each of the two neighbors @@ -393,18 +393,18 @@ void nsTableBorderCollapser::ComputeTopBorderForEdgeAt(nsIPresContext* aPresCont nsVoidArray styles; // styles are added to the array in the order least dominant -> most dominant // 1. table - const nsStyleSpacing *spacing; - mTableFrame.GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + const nsStyleBorder *borderStyleData; + mTableFrame.GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 2. colgroup nsTableColFrame* colFrame = mTableFrame.GetColFrame(aColIndex); nsIFrame* colGroupFrame; colFrame->GetParent(&colGroupFrame); - colGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 3. col - colFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 4. rowgroup nsTableCellFrame* cellFrame = cellMap->GetCellInfoAt(aRowIndex, aColIndex); if (cellFrame) { @@ -412,14 +412,14 @@ void nsTableBorderCollapser::ComputeTopBorderForEdgeAt(nsIPresContext* aPresCont cellFrame->GetParent(&rowFrame); nsIFrame* rowGroupFrame; rowFrame->GetParent(&rowGroupFrame); - rowGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 5. row - rowFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 6. cell (need to do something smart for rowspanner with row frame) - cellFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + cellFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } ComputeBorderSegment(NS_SIDE_TOP, &styles, *border, PR_FALSE); // now give half the computed border to the table segment, and half to the cell @@ -505,21 +505,21 @@ void nsTableBorderCollapser::ComputeBottomBorderForEdgeAt(nsIPresContext* aPresC } } } - const nsStyleSpacing *spacing; + const nsStyleBorder *borderStyleData; if (!bottomNeighborFrame) { // if bottomNeighborFrame is null, our bottom neighbor is the table - mTableFrame.GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + mTableFrame.GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 2. colgroup // XXX: need to deterine if we're on a colgroup boundary nsTableColFrame* colFrame = mTableFrame.GetColFrame(aColIndex); nsIFrame* colGroupFrame; colFrame->GetParent(&colGroupFrame); - colGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 3. col - colFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + colFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } // 4. rowgroup // XXX: use rowgroup only if we're on a table edge nsTableCellFrame* cellFrame = cellMap->GetCellInfoAt(aRowIndex, aColIndex); @@ -530,19 +530,19 @@ void nsTableBorderCollapser::ComputeBottomBorderForEdgeAt(nsIPresContext* aPresC rowFrame->GetRect(rowRect); nsIFrame* rowGroupFrame; rowFrame->GetParent(&rowGroupFrame); - rowGroupFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowGroupFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 5. row - rowFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + rowFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); // 6. cell (need to do something smart for rowspanner with row frame) - cellFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + cellFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } // 7. top edge of bottomNeighborCell, if there is one if (bottomNeighborFrame) { - bottomNeighborFrame->GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)spacing)); - styles.AppendElement((void*)spacing); + bottomNeighborFrame->GetStyleData(eStyleStruct_Border, ((const nsStyleStruct *&)borderStyleData)); + styles.AppendElement((void*)borderStyleData); } ComputeBorderSegment(NS_SIDE_BOTTOM, &styles, border, (nsnull != bottomNeighborFrame)); // now give half the computed border to each of the two neighbors @@ -740,33 +740,33 @@ void nsTableBorderCollapser::ComputeBorderSegment(PRUint8 aSide, PRInt32 styleCount = aStyles->Count(); if (0 != styleCount) { nsVoidArray sameWidthBorders; - nsStyleSpacing * spacing; - nsStyleSpacing * lastSpacing=nsnull; + nsStyleBorder * borderStyleData; + nsStyleBorder * lastBorderStyleData=nsnull; nsMargin border; PRInt32 maxWidth=0; PRUint8 side = aSide; PRInt32 i; for (i = 0; i < styleCount; i++) { - spacing = (nsStyleSpacing *)(aStyles->ElementAt(i)); + borderStyleData = (nsStyleBorder *)(aStyles->ElementAt(i)); if (aFlipLastSide && (i == styleCount-1)) { side = GetOpposingEdge(aSide); - lastSpacing = spacing; + lastBorderStyleData = borderStyleData; } - if (spacing->GetBorderStyle(side) == NS_STYLE_BORDER_STYLE_HIDDEN) { + if (borderStyleData->GetBorderStyle(side) == NS_STYLE_BORDER_STYLE_HIDDEN) { aBorder.mStyle=NS_STYLE_BORDER_STYLE_HIDDEN; aBorder.mWidth=0; return; } - else if (spacing->GetBorderStyle(side)!=NS_STYLE_BORDER_STYLE_NONE) { - if (spacing->GetBorder(border)) { + else if (borderStyleData->GetBorderStyle(side)!=NS_STYLE_BORDER_STYLE_NONE) { + if (borderStyleData->GetBorder(border)) { nscoord borderWidth = GetWidthForSide(border, side); if (borderWidth == maxWidth) { - sameWidthBorders.AppendElement(spacing); + sameWidthBorders.AppendElement(borderStyleData); } else if (borderWidth > maxWidth) { maxWidth = borderWidth; sameWidthBorders.Clear(); - sameWidthBorders.AppendElement(spacing); + sameWidthBorders.AppendElement(borderStyleData); } } } @@ -782,38 +782,38 @@ void nsTableBorderCollapser::ComputeBorderSegment(PRUint8 aSide, return; } else if (1 == styleCount) { // there was just one border of the largest width - spacing = (nsStyleSpacing *)(sameWidthBorders.ElementAt(0)); + borderStyleData = (nsStyleBorder *)(sameWidthBorders.ElementAt(0)); side = aSide; - if (spacing == lastSpacing) + if (borderStyleData == lastBorderStyleData) side = GetOpposingEdge(aSide); - if (!spacing->GetBorderColor(side, aBorder.mColor)) { + if (!borderStyleData->GetBorderColor(side, aBorder.mColor)) { // XXX EEEK handle transparent border color somehow... } - aBorder.mStyle = spacing->GetBorderStyle(side); + aBorder.mStyle = borderStyleData->GetBorderStyle(side); return; } else { - nsStyleSpacing* winningStyleBorder; + nsStyleBorder* winningStyleBorder; PRUint8 winningStyle=NS_STYLE_BORDER_STYLE_NONE; for (i = 0; i < styleCount; i++) { - spacing = (nsStyleSpacing *)(sameWidthBorders.ElementAt(i)); + borderStyleData = (nsStyleBorder *)(sameWidthBorders.ElementAt(i)); side = aSide; - if (spacing == lastSpacing) + if (borderStyleData == lastBorderStyleData) side = GetOpposingEdge(aSide); - PRUint8 thisStyle = spacing->GetBorderStyle(side); + PRUint8 thisStyle = borderStyleData->GetBorderStyle(side); PRUint8 borderCompare = CompareBorderStyles(thisStyle, winningStyle); if (BORDER_PRECEDENT_HIGHER == borderCompare) { winningStyle = thisStyle; - winningStyleBorder = spacing; + winningStyleBorder = borderStyleData; } else if (BORDER_PRECEDENT_EQUAL == borderCompare) { // we're in lowest-to-highest precedence order, so later border styles win - winningStyleBorder=spacing; + winningStyleBorder=borderStyleData; } } aBorder.mStyle = winningStyle; side = aSide; - if (winningStyleBorder == lastSpacing) + if (winningStyleBorder == lastBorderStyleData) side = GetOpposingEdge(aSide); if (!winningStyleBorder->GetBorderColor(side, aBorder.mColor)) { // XXX handle transparent border colors somehow diff --git a/mozilla/layout/html/table/src/nsTableCellFrame.cpp b/mozilla/layout/html/table/src/nsTableCellFrame.cpp index d8aed1f6884..9fa56143b9d 100644 --- a/mozilla/layout/html/table/src/nsTableCellFrame.cpp +++ b/mozilla/layout/html/table/src/nsTableCellFrame.cpp @@ -291,10 +291,10 @@ NS_METHOD nsTableCellFrame::Paint(nsIPresContext* aPresContext, } //END SELECTION - const nsStyleSpacing* mySpacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); NS_ASSERTION(nsnull!=myColor, "bad style color"); - NS_ASSERTION(nsnull!=mySpacing, "bad style spacing"); + NS_ASSERTION(nsnull!=myBorder, "bad style spacing"); const nsStyleTable* cellTableStyle; GetStyleData(eStyleStruct_Table, ((const nsStyleStruct *&)cellTableStyle)); @@ -303,7 +303,7 @@ NS_METHOD nsTableCellFrame::Paint(nsIPresContext* aPresContext, // only non empty cells render their background if (PR_FALSE == GetContentEmpty()) { nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *myColor, *mySpacing, 0, 0); + aDirtyRect, rect, *myColor, *myBorder, 0, 0); } // empty cells do not render their border @@ -325,7 +325,7 @@ NS_METHOD nsTableCellFrame::Paint(nsIPresContext* aPresContext, if (NS_STYLE_BORDER_SEPARATE == tableFrame->GetBorderCollapseStyle()) { nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mStyleContext, skipSides); + aDirtyRect, rect, *myBorder, mStyleContext, skipSides); } else { @@ -787,7 +787,7 @@ NS_METHOD nsTableCellFrame::Reflow(nsIPresContext* aPresContext, kidOrigin.MoveTo(leftInset, topInset); } else { // handle percent padding-left which was 0 during initial reflow - if (eStyleUnit_Percent == aReflowState.mStyleSpacing->mPadding.GetLeftUnit()) { + if (eStyleUnit_Percent == aReflowState.mStylePadding->mPadding.GetLeftUnit()) { nsRect kidRect; firstKid->GetRect(kidRect); // only move in the x direction for the same reason as above @@ -928,7 +928,7 @@ NS_METHOD nsTableCellFrame::Reflow(nsIPresContext* aPresContext, * */ void nsTableCellFrame::MapHTMLBorderStyle(nsIPresContext* aPresContext, - nsStyleSpacing& aSpacingStyle, + nsStyleBorder& aBorderStyle, nsTableFrame* aTableFrame) { //adjust the border style based on the table rules attribute @@ -942,20 +942,20 @@ void nsTableCellFrame::MapHTMLBorderStyle(nsIPresContext* aPresContext, switch (tableStyle->mRules) { case NS_STYLE_TABLE_RULES_NONE: - aSpacingStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_RULES_COLS: - aSpacingStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_RULES_ROWS: - aSpacingStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); break; default: @@ -996,9 +996,9 @@ void nsTableCellFrame::MapBorderPadding(nsIPresContext* aPresContext) // get the table frame style context, and from it get cellpadding, cellspacing, and border info const nsStyleTable* tableStyle; tableFrame->GetStyleData(eStyleStruct_Table, (const nsStyleStruct *&)tableStyle); - const nsStyleSpacing* tableSpacingStyle; - tableFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct *&)tableSpacingStyle); - nsStyleSpacing* spacingData = (nsStyleSpacing*)mStyleContext->GetMutableStyleData(eStyleStruct_Spacing); + const nsStylePadding* tablePaddingStyle; + tableFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct *&)tablePaddingStyle); + nsStylePadding* paddingData = (nsStylePadding*)mStyleContext->GetMutableStyleData(eStyleStruct_Padding); float p2t; aPresContext->GetPixelsToTwips(&p2t); @@ -1011,16 +1011,17 @@ void nsTableCellFrame::MapBorderPadding(nsIPresContext* aPresContext) } // if the padding is not already set, set it to the table's cellpadding - if (eStyleUnit_Null == spacingData->mPadding.GetTopUnit()) - spacingData->mPadding.SetTop(defaultPadding); - if (eStyleUnit_Null == spacingData->mPadding.GetRightUnit()) - spacingData->mPadding.SetRight(defaultPadding); - if (eStyleUnit_Null == spacingData->mPadding.GetBottomUnit()) - spacingData->mPadding.SetBottom(defaultPadding); - if (eStyleUnit_Null == spacingData->mPadding.GetLeftUnit()) - spacingData->mPadding.SetLeft(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetTopUnit()) + paddingData->mPadding.SetTop(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetRightUnit()) + paddingData->mPadding.SetRight(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetBottomUnit()) + paddingData->mPadding.SetBottom(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetLeftUnit()) + paddingData->mPadding.SetLeft(defaultPadding); - MapHTMLBorderStyle(aPresContext, *spacingData, tableFrame); + nsStyleBorder* borderData = (nsStyleBorder*)mStyleContext->GetMutableStyleData(eStyleStruct_Border); + MapHTMLBorderStyle(aPresContext, *borderData, tableFrame); MapVAlignAttribute(aPresContext, tableFrame); MapHAlignAttribute(aPresContext, tableFrame); @@ -1271,9 +1272,9 @@ nsTableCellFrame::GetCellBorder(nsMargin& aBorder, NS_PRECONDITION(mBorderEdges, "haven't allocated border edges struct"); aBorder = mBorderEdges->mMaxBorderWidth; } else { - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - spacing->GetBorder(aBorder); + const nsStyleBorder* borderData; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderData); + borderData->GetBorder(aBorder); } } diff --git a/mozilla/layout/html/table/src/nsTableCellFrame.h b/mozilla/layout/html/table/src/nsTableCellFrame.h index 54062378e81..34cfaa32c77 100644 --- a/mozilla/layout/html/table/src/nsTableCellFrame.h +++ b/mozilla/layout/html/table/src/nsTableCellFrame.h @@ -28,7 +28,6 @@ #include "nsTableRowFrame.h" // need to actually include this here to inline GetRowIndex #include "nsIStyleContext.h" -struct nsStyleSpacing; class nsTableFrame; class nsHTMLValue; @@ -257,7 +256,7 @@ protected: void MapBorderPadding(nsIPresContext* aPresContext); void MapHTMLBorderStyle(nsIPresContext* aPresContext, - nsStyleSpacing& aSpacingStyle, + nsStyleBorder& aBorderStyle, nsTableFrame* aTableFrame); void MapVAlignAttribute(nsIPresContext* aPresContext, nsTableFrame *aTableFrame); diff --git a/mozilla/layout/html/table/src/nsTableColFrame.cpp b/mozilla/layout/html/table/src/nsTableColFrame.cpp index 2b0905e7698..81be1b7f76d 100644 --- a/mozilla/layout/html/table/src/nsTableColFrame.cpp +++ b/mozilla/layout/html/table/src/nsTableColFrame.cpp @@ -115,13 +115,13 @@ NS_METHOD nsTableColFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp b/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp index 2d4e048e81d..fa4fd76c5ec 100644 --- a/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp +++ b/mozilla/layout/html/table/src/nsTableColGroupFrame.cpp @@ -441,13 +441,13 @@ NS_METHOD nsTableColGroupFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/html/table/src/nsTableFrame.cpp b/mozilla/layout/html/table/src/nsTableFrame.cpp index 17b1b821487..0534a6ac401 100644 --- a/mozilla/layout/html/table/src/nsTableFrame.cpp +++ b/mozilla/layout/html/table/src/nsTableFrame.cpp @@ -575,16 +575,16 @@ void nsTableFrame::ProcessGroupRules(nsIPresContext* aPresContext) if (originates) { nsCOMPtr styleContext; cell->GetStyleContext(getter_AddRefs(styleContext)); - nsStyleSpacing* spacing = (nsStyleSpacing*)styleContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* border = (nsStyleBorder*)styleContext->GetMutableStyleData(eStyleStruct_Border); if (rowX == startRow) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); } else if (rowX == endRow) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); } else { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); } styleContext->RecalcAutomaticData(aPresContext); } @@ -1330,8 +1330,8 @@ NS_METHOD nsTableFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); @@ -1341,7 +1341,7 @@ NS_METHOD nsTableFrame::Paint(nsIPresContext* aPresContext, aPresContext->GetCompatibilityMode(&mode); if (eCompatibility_NavQuirks != mode) { nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } // paint the column groups and columns nsIFrame* colGroupFrame = mColGroups.FirstChild(); @@ -1354,7 +1354,7 @@ NS_METHOD nsTableFrame::Paint(nsIPresContext* aPresContext, if (NS_STYLE_BORDER_SEPARATE == GetBorderCollapseStyle()) { nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *border, mStyleContext, skipSides); } else { @@ -1515,8 +1515,6 @@ nsresult nsTableFrame::AdjustSiblingsAfterReflow(nsIPresContext* aPresCon // Update the max element size //XXX: this should call into layout strategy to get the width field if (aMaxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -1865,10 +1863,10 @@ NS_METHOD nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresContext, // Get the table's border padding nsMargin borderPadding; GetTableBorderForRowGroup(GetRowGroupFrame(kidFrame), borderPadding); - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)tableSpacing)); + const nsStylePadding* tablePadding; + GetStyleData(eStyleStruct_Padding, ((const nsStyleStruct *&)tablePadding)); nsMargin padding; - tableSpacing->GetPadding(padding); + tablePadding->GetPadding(padding); borderPadding += padding; y += cellSpacingY; @@ -1923,12 +1921,12 @@ NS_METHOD nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresContext, } // Get the table's border/padding - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStylePadding* myPadding = (const nsStylePadding*) + mStyleContext->GetStyleData(eStyleStruct_Padding); nsMargin tableBorderPadding; GetTableBorder (tableBorderPadding); // this gets the max border thickness at each edge nsMargin tablePadding; - mySpacing->GetPadding(tablePadding); + myPadding->GetPadding(tablePadding); tableBorderPadding += tablePadding; aDesiredSize.width = kidSize.width; @@ -2790,8 +2788,6 @@ nsTableFrame::RecoverState(InnerTableReflowState& aReflowState, //XXX: this should call into layout strategy to get the width field if (nsnull != aMaxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -2852,8 +2848,6 @@ NS_METHOD nsTableFrame::IR_TargetIsChild(nsIPresContext* aPresContext, //XXX: this should call into layout strategy to get the width field if (nsnull != aDesiredSize.maxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -2972,8 +2966,6 @@ void nsTableFrame::PlaceChild(nsIPresContext* aPresContext, //XXX: this should call into layout strategy to get the width field if (nsnull != aMaxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -3106,8 +3098,6 @@ NS_METHOD nsTableFrame::ReflowMappedChildren(nsIPresContext* aPresContext nsMargin borderPadding; GetTableBorderForRowGroup(GetRowGroupFrame(kidFrame), borderPadding); - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)tableSpacing)); borderPadding += aReflowState.reflowState.mComputedPadding; // Reflow the child into the available space @@ -3789,19 +3779,19 @@ void nsTableFrame::SetColumnWidth(PRInt32 aColIndex, nscoord aWidth) * Update the border style to map to the HTML border style * */ -void nsTableFrame::MapHTMLBorderStyle(nsStyleSpacing& aSpacingStyle, nscoord aBorderWidth) +void nsTableFrame::MapHTMLBorderStyle(nsStyleBorder& aBorderStyle, nscoord aBorderWidth) { nsStyleCoord width; width.SetCoordValue(aBorderWidth); - aSpacingStyle.mBorder.SetTop(width); - aSpacingStyle.mBorder.SetLeft(width); - aSpacingStyle.mBorder.SetBottom(width); - aSpacingStyle.mBorder.SetRight(width); + aBorderStyle.mBorder.SetTop(width); + aBorderStyle.mBorder.SetLeft(width); + aBorderStyle.mBorder.SetBottom(width); + aBorderStyle.mBorder.SetRight(width); - aSpacingStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_BG_OUTSET); - aSpacingStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_BG_OUTSET); - aSpacingStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_BG_OUTSET); - aSpacingStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_BG_OUTSET); nsIStyleContext* styleContext = mStyleContext; const nsStyleColor* colorData = (const nsStyleColor*) @@ -3839,10 +3829,10 @@ void nsTableFrame::MapHTMLBorderStyle(nsStyleSpacing& aSpacingStyle, nscoord aBo if (borderColor == 0xFFFFFFFF) borderColor = 0xFFC0C0C0; - aSpacingStyle.SetBorderColor(NS_SIDE_TOP, borderColor); - aSpacingStyle.SetBorderColor(NS_SIDE_LEFT, borderColor); - aSpacingStyle.SetBorderColor(NS_SIDE_BOTTOM, borderColor); - aSpacingStyle.SetBorderColor(NS_SIDE_RIGHT, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_TOP, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_LEFT, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_BOTTOM, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_RIGHT, borderColor); } @@ -3890,7 +3880,7 @@ void nsTableFrame::MapBorderMarginPadding(nsIPresContext* aPresContext) if (!table) return; - nsStyleSpacing* spacingData = (nsStyleSpacing*)mStyleContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* borderData = (nsStyleBorder*)mStyleContext->GetMutableStyleData(eStyleStruct_Border); border_result = table->GetAttribute(nsHTMLAtoms::border,border_value); if (border_result == NS_CONTENT_ATTR_HAS_VALUE) @@ -3900,7 +3890,7 @@ void nsTableFrame::MapBorderMarginPadding(nsIPresContext* aPresContext) if (ConvertToPixelValue(border_value,1,intValue)) //XXX this is busted if this code is ever used again. MMP border = NSIntPixelsToTwips(intValue, p2t); } - MapHTMLBorderStyle(*spacingData,border); + MapHTMLBorderStyle(*borderData,border); #endif } @@ -3915,39 +3905,39 @@ CalcPercentPadding(nscoord aBasis, void GetPaddingFor(const nsSize& aBasis, - const nsStyleSpacing& aSpacing, + const nsStylePadding& aPaddingData, nsMargin& aPadding) { nsStyleCoord styleCoord; - aSpacing.mPadding.GetTop(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetTopUnit()) { + aPaddingData.mPadding.GetTop(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetTopUnit()) { aPadding.top = CalcPercentPadding(aBasis.height, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.top = styleCoord.GetCoordValue(); } - aSpacing.mPadding.GetRight(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetRightUnit()) { + aPaddingData.mPadding.GetRight(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetRightUnit()) { aPadding.right = CalcPercentPadding(aBasis.width, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.right = styleCoord.GetCoordValue(); } - aSpacing.mPadding.GetBottom(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetBottomUnit()) { + aPaddingData.mPadding.GetBottom(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetBottomUnit()) { aPadding.bottom = CalcPercentPadding(aBasis.height, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.bottom = styleCoord.GetCoordValue(); } - aSpacing.mPadding.GetLeft(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetLeftUnit()) { + aPaddingData.mPadding.GetLeft(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetLeftUnit()) { aPadding.left = CalcPercentPadding(aBasis.width, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.left = styleCoord.GetCoordValue(); } } @@ -3956,10 +3946,10 @@ nsMargin nsTableFrame::GetPadding(const nsHTMLReflowState& aReflowState, const nsTableCellFrame* aCellFrame) { - const nsStyleSpacing* spacing; - aCellFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct *&)spacing); + const nsStylePadding* paddingData; + aCellFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct *&)paddingData); nsMargin padding(0,0,0,0); - if (!spacing->GetPadding(padding)) { + if (!paddingData->GetPadding(padding)) { const nsHTMLReflowState* parentRS = aReflowState.parentReflowState; while (parentRS) { if (parentRS->frame) { @@ -3967,7 +3957,7 @@ nsTableFrame::GetPadding(const nsHTMLReflowState& aReflowState, parentRS->frame->GetFrameType(getter_AddRefs(frameType)); if (nsLayoutAtoms::tableFrame == frameType.get()) { nsSize basis(parentRS->mComputedWidth, parentRS->mComputedHeight); - GetPaddingFor(basis, *spacing, padding); + GetPaddingFor(basis, *paddingData, padding); break; } } @@ -3981,11 +3971,11 @@ nsMargin nsTableFrame::GetPadding(const nsSize& aBasis, const nsTableCellFrame* aCellFrame) { - const nsStyleSpacing* spacing; - aCellFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct *&)spacing); + const nsStylePadding* paddingData; + aCellFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct *&)paddingData); nsMargin padding(0,0,0,0); - if (!spacing->GetPadding(padding)) { - GetPaddingFor(aBasis, *spacing, padding); + if (!paddingData->GetPadding(padding)) { + GetPaddingFor(aBasis, *paddingData, padding); } return padding; } @@ -3997,9 +3987,9 @@ void nsTableFrame::GetTableBorder(nsMargin &aBorder) mBorderCollapser->GetBorder(aBorder); } else { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); - spacing->GetBorder(aBorder); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); + border->GetBorder(aBorder); } } @@ -4019,9 +4009,9 @@ void nsTableFrame::GetTableBorderAt(PRInt32 aRowIndex, } } else { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); - spacing->GetBorder(aBorder); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); + border->GetBorder(aBorder); } } @@ -4211,13 +4201,16 @@ nscoord nsTableFrame::CalcBorderBoxWidth(const nsHTMLReflowState& aState) } if (NS_UNCONSTRAINEDSIZE != aState.availableWidth) { nsMargin margin(0,0,0,0); - aState.mStyleSpacing->GetMargin(margin); + aState.mStyleMargin->GetMargin(margin); width = aState.availableWidth - margin.left - margin.right; } } else if (width != NS_UNCONSTRAINEDSIZE) { + nsMargin border(0,0,0,0); + aState.mStyleBorder->GetBorder(border); nsMargin borderPadding(0,0,0,0); - aState.mStyleSpacing->GetBorderPadding(borderPadding); + aState.mStylePadding->GetPadding(borderPadding); + borderPadding += border; width += borderPadding.left + borderPadding.right; } width = PR_MAX(width, 0); diff --git a/mozilla/layout/html/table/src/nsTableFrame.h b/mozilla/layout/html/table/src/nsTableFrame.h index 1474fbc22c3..0a083ddda1d 100644 --- a/mozilla/layout/html/table/src/nsTableFrame.h +++ b/mozilla/layout/html/table/src/nsTableFrame.h @@ -44,7 +44,6 @@ class nsHTMLValue; struct InnerTableReflowState; struct nsStylePosition; -struct nsStyleSpacing; /** * Child list name indices @@ -708,7 +707,7 @@ protected: /** Support methods for DidSetStyleContext */ void MapBorderMarginPadding(nsIPresContext* aPresContext); - void MapHTMLBorderStyle(nsStyleSpacing& aSpacingStyle, nscoord aBorderWidth); + void MapHTMLBorderStyle(nsStyleBorder& aBorderStyle, nscoord aBorderWidth); PRBool ConvertToPixelValue(nsHTMLValue& aValue, PRInt32 aDefault, PRInt32& aResult); public: diff --git a/mozilla/layout/html/table/src/nsTableOuterFrame.cpp b/mozilla/layout/html/table/src/nsTableOuterFrame.cpp index 60593a093b5..b2ce6dedb72 100644 --- a/mozilla/layout/html/table/src/nsTableOuterFrame.cpp +++ b/mozilla/layout/html/table/src/nsTableOuterFrame.cpp @@ -432,10 +432,10 @@ void nsTableOuterFrame::ZeroAutoMargin(nsHTMLReflowState& aReflowState, nsMargin& aMargin) { - if (eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetLeftUnit()) { aMargin.left = 0; } - if (eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetRightUnit()) { aMargin.right = 0; } } @@ -445,8 +445,8 @@ FixAutoMargins(nscoord aAvailWidth, nsHTMLReflowState& aReflowState) { // see if there are auto margins. they may have been set to 0 in mComputedMargin - PRBool hasAutoMargin = eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetLeftUnit() || - eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetRightUnit(); + PRBool hasAutoMargin = eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetLeftUnit() || + eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetRightUnit(); if (hasAutoMargin) { nsRect rect; aReflowState.frame->GetRect(rect); diff --git a/mozilla/layout/html/table/src/nsTableRowFrame.cpp b/mozilla/layout/html/table/src/nsTableRowFrame.cpp index e2d6aa45201..5cfb70a0490 100644 --- a/mozilla/layout/html/table/src/nsTableRowFrame.cpp +++ b/mozilla/layout/html/table/src/nsTableRowFrame.cpp @@ -511,8 +511,8 @@ NS_METHOD nsTableRowFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsTableFrame* tableFrame = nsnull; @@ -525,7 +525,7 @@ NS_METHOD nsTableRowFrame::Paint(nsIPresContext* aPresContext, nsRect rect(0, 0, mRect.width + cellSpacingX, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp b/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp index 81796fadfd4..ee035cc2aaf 100644 --- a/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp +++ b/mozilla/layout/html/table/src/nsTableRowGroupFrame.cpp @@ -199,8 +199,8 @@ NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsTableFrame* tableFrame = nsnull; @@ -210,7 +210,7 @@ NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext* aPresContext, } nsRect rect(0,0,mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/style/nsCSSStyleRule.cpp b/mozilla/layout/style/nsCSSStyleRule.cpp index 080ad738b15..9027baeb677 100644 --- a/mozilla/layout/style/nsCSSStyleRule.cpp +++ b/mozilla/layout/style/nsCSSStyleRule.cpp @@ -2253,33 +2253,41 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nsCSSMargin* ourMargin; if (NS_OK == aDeclaration->GetData(kCSSMarginSID, (nsCSSStruct**)&ourMargin)) { if (nsnull != ourMargin) { - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleMargin* margin = (nsStyleMargin*)aContext->GetMutableStyleData(eStyleStruct_Margin); + nsStylePadding* padding = (nsStylePadding*)aContext->GetMutableStyleData(eStyleStruct_Padding); + nsStyleBorder* border = (nsStyleBorder*)aContext->GetMutableStyleData(eStyleStruct_Border); + nsStyleOutline* outline = (nsStyleOutline*)aContext->GetMutableStyleData(eStyleStruct_Outline); - const nsStyleSpacing* parentSpacing = spacing; + const nsStyleMargin* parentMargin = margin; + const nsStylePadding* parentPadding = padding; + const nsStyleBorder* parentBorder = border; + const nsStyleOutline* parentOutline = outline; if (nsnull != aParentContext) { - parentSpacing = (const nsStyleSpacing*)aParentContext->GetStyleData(eStyleStruct_Spacing); + parentMargin = (const nsStyleMargin*)aParentContext->GetStyleData(eStyleStruct_Margin); + parentPadding = (const nsStylePadding*)aParentContext->GetStyleData(eStyleStruct_Padding); + parentBorder = (const nsStyleBorder*)aParentContext->GetStyleData(eStyleStruct_Border); + parentOutline = (const nsStyleOutline*)aParentContext->GetStyleData(eStyleStruct_Outline); } // margin: length, percent, auto, inherit if (nsnull != ourMargin->mMargin) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mMargin.GetLeft(parentCoord); + parentMargin->mMargin.GetLeft(parentCoord); if (SetCoord(ourMargin->mMargin->mLeft, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetLeft(coord); + margin->mMargin.SetLeft(coord); } - parentSpacing->mMargin.GetTop(parentCoord); + parentMargin->mMargin.GetTop(parentCoord); if (SetCoord(ourMargin->mMargin->mTop, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetTop(coord); + margin->mMargin.SetTop(coord); } - parentSpacing->mMargin.GetRight(parentCoord); + parentMargin->mMargin.GetRight(parentCoord); if (SetCoord(ourMargin->mMargin->mRight, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetRight(coord); + margin->mMargin.SetRight(coord); } - parentSpacing->mMargin.GetBottom(parentCoord); + parentMargin->mMargin.GetBottom(parentCoord); if (SetCoord(ourMargin->mMargin->mBottom, coord, parentCoord, SETCOORD_LPAH, aFont->mFont, aPresContext)) { - spacing->mMargin.SetBottom(coord); + margin->mMargin.SetBottom(coord); } } @@ -2287,21 +2295,21 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mPadding) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mPadding.GetLeft(parentCoord); + parentPadding->mPadding.GetLeft(parentCoord); if (SetCoord(ourMargin->mPadding->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetLeft(coord); + padding->mPadding.SetLeft(coord); } - parentSpacing->mPadding.GetTop(parentCoord); + parentPadding->mPadding.GetTop(parentCoord); if (SetCoord(ourMargin->mPadding->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetTop(coord); + padding->mPadding.SetTop(coord); } - parentSpacing->mPadding.GetRight(parentCoord); + parentPadding->mPadding.GetRight(parentCoord); if (SetCoord(ourMargin->mPadding->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetRight(coord); + padding->mPadding.SetRight(coord); } - parentSpacing->mPadding.GetBottom(parentCoord); + parentPadding->mPadding.GetBottom(parentCoord); if (SetCoord(ourMargin->mPadding->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mPadding.SetBottom(coord); + padding->mPadding.SetBottom(coord); } } @@ -2310,31 +2318,31 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nsStyleCoord coord; nsStyleCoord parentCoord; if (SetCoord(ourMargin->mBorderWidth->mLeft, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetLeft(coord); + border->mBorder.SetLeft(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mLeft.GetUnit()) { - spacing->mBorder.SetLeft(parentSpacing->mBorder.GetLeft(coord)); + border->mBorder.SetLeft(parentBorder->mBorder.GetLeft(coord)); } if (SetCoord(ourMargin->mBorderWidth->mTop, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetTop(coord); + border->mBorder.SetTop(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mTop.GetUnit()) { - spacing->mBorder.SetTop(parentSpacing->mBorder.GetTop(coord)); + border->mBorder.SetTop(parentBorder->mBorder.GetTop(coord)); } if (SetCoord(ourMargin->mBorderWidth->mRight, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetRight(coord); + border->mBorder.SetRight(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mRight.GetUnit()) { - spacing->mBorder.SetRight(parentSpacing->mBorder.GetRight(coord)); + border->mBorder.SetRight(parentBorder->mBorder.GetRight(coord)); } if (SetCoord(ourMargin->mBorderWidth->mBottom, coord, parentCoord, SETCOORD_LE, aFont->mFont, aPresContext)) { - spacing->mBorder.SetBottom(coord); + border->mBorder.SetBottom(coord); } else if (eCSSUnit_Inherit == ourMargin->mBorderWidth->mBottom.GetUnit()) { - spacing->mBorder.SetBottom(parentSpacing->mBorder.GetBottom(coord)); + border->mBorder.SetBottom(parentBorder->mBorder.GetBottom(coord)); } } @@ -2342,43 +2350,43 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mBorderStyle) { nsCSSRect* ourStyle = ourMargin->mBorderStyle; if (eCSSUnit_Enumerated == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, ourStyle->mTop.GetIntValue()); + border->SetBorderStyle(NS_SIDE_TOP, ourStyle->mTop.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mTop.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_TOP, parentSpacing->GetBorderStyle(NS_SIDE_TOP)); + border->SetBorderStyle(NS_SIDE_TOP, parentBorder->GetBorderStyle(NS_SIDE_TOP)); } if (eCSSUnit_Enumerated == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, ourStyle->mRight.GetIntValue()); + border->SetBorderStyle(NS_SIDE_RIGHT, ourStyle->mRight.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mRight.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_RIGHT, parentSpacing->GetBorderStyle(NS_SIDE_RIGHT)); + border->SetBorderStyle(NS_SIDE_RIGHT, parentBorder->GetBorderStyle(NS_SIDE_RIGHT)); } if (eCSSUnit_Enumerated == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, ourStyle->mBottom.GetIntValue()); + border->SetBorderStyle(NS_SIDE_BOTTOM, ourStyle->mBottom.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mBottom.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, parentSpacing->GetBorderStyle(NS_SIDE_BOTTOM)); + border->SetBorderStyle(NS_SIDE_BOTTOM, parentBorder->GetBorderStyle(NS_SIDE_BOTTOM)); } if (eCSSUnit_Enumerated == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, ourStyle->mLeft.GetIntValue()); + border->SetBorderStyle(NS_SIDE_LEFT, ourStyle->mLeft.GetIntValue()); } else if (eCSSUnit_None == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourStyle->mLeft.GetUnit()) { - spacing->SetBorderStyle(NS_SIDE_LEFT, parentSpacing->GetBorderStyle(NS_SIDE_LEFT)); + border->SetBorderStyle(NS_SIDE_LEFT, parentBorder->GetBorderStyle(NS_SIDE_LEFT)); } } @@ -2389,63 +2397,63 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nscolor unused = NS_RGB(0,0,0); if (eCSSUnit_Inherit == ourBorderColor->mTop.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_TOP, borderColor)) { - spacing->SetBorderColor(NS_SIDE_TOP, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_TOP, borderColor)) { + border->SetBorderColor(NS_SIDE_TOP, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_TOP); + border->SetBorderTransparent(NS_SIDE_TOP); } } else if (SetColor(ourBorderColor->mTop, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_TOP, borderColor); + border->SetBorderColor(NS_SIDE_TOP, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mTop.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_TOP); + border->SetBorderTransparent(NS_SIDE_TOP); } if (eCSSUnit_Inherit == ourBorderColor->mRight.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_RIGHT, borderColor)) { - spacing->SetBorderColor(NS_SIDE_RIGHT, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_RIGHT, borderColor)) { + border->SetBorderColor(NS_SIDE_RIGHT, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_RIGHT); + border->SetBorderTransparent(NS_SIDE_RIGHT); } } else if (SetColor(ourBorderColor->mRight, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_RIGHT, borderColor); + border->SetBorderColor(NS_SIDE_RIGHT, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mRight.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_RIGHT); + border->SetBorderTransparent(NS_SIDE_RIGHT); } if (eCSSUnit_Inherit == ourBorderColor->mBottom.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_BOTTOM, borderColor)) { - spacing->SetBorderColor(NS_SIDE_BOTTOM, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_BOTTOM, borderColor)) { + border->SetBorderColor(NS_SIDE_BOTTOM, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_BOTTOM); + border->SetBorderTransparent(NS_SIDE_BOTTOM); } } else if (SetColor(ourBorderColor->mBottom, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_BOTTOM, borderColor); + border->SetBorderColor(NS_SIDE_BOTTOM, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mBottom.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_BOTTOM); + border->SetBorderTransparent(NS_SIDE_BOTTOM); } if (eCSSUnit_Inherit == ourBorderColor->mLeft.GetUnit()) { - if (parentSpacing->GetBorderColor(NS_SIDE_LEFT, borderColor)) { - spacing->SetBorderColor(NS_SIDE_LEFT, borderColor); + if (parentBorder->GetBorderColor(NS_SIDE_LEFT, borderColor)) { + border->SetBorderColor(NS_SIDE_LEFT, borderColor); } else { - spacing->SetBorderTransparent(NS_SIDE_LEFT); + border->SetBorderTransparent(NS_SIDE_LEFT); } } else if (SetColor(ourBorderColor->mLeft, unused, aPresContext, borderColor)) { - spacing->SetBorderColor(NS_SIDE_LEFT, borderColor); + border->SetBorderColor(NS_SIDE_LEFT, borderColor); } else if (eCSSUnit_Enumerated == ourBorderColor->mLeft.GetUnit()) { - spacing->SetBorderTransparent(NS_SIDE_LEFT); + border->SetBorderTransparent(NS_SIDE_LEFT); } } @@ -2453,21 +2461,21 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mBorderRadius) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mBorderRadius.GetLeft(parentCoord); + parentBorder->mBorderRadius.GetLeft(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetLeft(coord); + border->mBorderRadius.SetLeft(coord); } - parentSpacing->mBorderRadius.GetTop(parentCoord); + parentBorder->mBorderRadius.GetTop(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetTop(coord); + border->mBorderRadius.SetTop(coord); } - parentSpacing->mBorderRadius.GetRight(parentCoord); + parentBorder->mBorderRadius.GetRight(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetRight(coord); + border->mBorderRadius.SetRight(coord); } - parentSpacing->mBorderRadius.GetBottom(parentCoord); + parentBorder->mBorderRadius.GetBottom(parentCoord); if (SetCoord(ourMargin->mBorderRadius->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mBorderRadius.SetBottom(coord); + border->mBorderRadius.SetBottom(coord); } } @@ -2475,26 +2483,26 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, if (nsnull != ourMargin->mOutlineRadius) { nsStyleCoord coord; nsStyleCoord parentCoord; - parentSpacing->mOutlineRadius.GetLeft(parentCoord); + parentOutline->mOutlineRadius.GetLeft(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mLeft, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetLeft(coord); + outline->mOutlineRadius.SetLeft(coord); } - parentSpacing->mOutlineRadius.GetTop(parentCoord); + parentOutline->mOutlineRadius.GetTop(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mTop, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetTop(coord); + outline->mOutlineRadius.SetTop(coord); } - parentSpacing->mOutlineRadius.GetRight(parentCoord); + parentOutline->mOutlineRadius.GetRight(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mRight, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetRight(coord); + outline->mOutlineRadius.SetRight(coord); } - parentSpacing->mOutlineRadius.GetBottom(parentCoord); + parentOutline->mOutlineRadius.GetBottom(parentCoord); if (SetCoord(ourMargin->mOutlineRadius->mBottom, coord, parentCoord, SETCOORD_LPH, aFont->mFont, aPresContext)) { - spacing->mOutlineRadius.SetBottom(coord); + outline->mOutlineRadius.SetBottom(coord); } } // outline-width: length, enum, inherit - if (! SetCoord(ourMargin->mOutlineWidth, spacing->mOutlineWidth, parentSpacing->mOutlineWidth, + if (! SetCoord(ourMargin->mOutlineWidth, outline->mOutlineWidth, parentOutline->mOutlineWidth, SETCOORD_LEH, aFont->mFont, aPresContext)) { } @@ -2502,37 +2510,37 @@ MapDeclarationMarginInto(nsICSSDeclaration* aDeclaration, nscolor outlineColor; nscolor unused = NS_RGB(0,0,0); if (eCSSUnit_Inherit == ourMargin->mOutlineColor.GetUnit()) { - if (parentSpacing->GetOutlineColor(outlineColor)) { - spacing->SetOutlineColor(outlineColor); + if (parentOutline->GetOutlineColor(outlineColor)) { + outline->SetOutlineColor(outlineColor); } else { - spacing->SetOutlineInvert(); + outline->SetOutlineInvert(); } } else if (SetColor(ourMargin->mOutlineColor, unused, aPresContext, outlineColor)) { - spacing->SetOutlineColor(outlineColor); + outline->SetOutlineColor(outlineColor); } else if (eCSSUnit_Enumerated == ourMargin->mOutlineColor.GetUnit()) { - spacing->SetOutlineInvert(); + outline->SetOutlineInvert(); } // outline-style: enum, none, inherit if (eCSSUnit_Enumerated == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(ourMargin->mOutlineStyle.GetIntValue()); + outline->SetOutlineStyle(ourMargin->mOutlineStyle.GetIntValue()); } else if (eCSSUnit_None == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(NS_STYLE_BORDER_STYLE_NONE); + outline->SetOutlineStyle(NS_STYLE_BORDER_STYLE_NONE); } else if (eCSSUnit_Inherit == ourMargin->mOutlineStyle.GetUnit()) { - spacing->SetOutlineStyle(parentSpacing->GetOutlineStyle()); + outline->SetOutlineStyle(parentOutline->GetOutlineStyle()); } // float-edge: enum, inherit if (eCSSUnit_Enumerated == ourMargin->mFloatEdge.GetUnit()) { - spacing->mFloatEdge = ourMargin->mFloatEdge.GetIntValue(); + border->mFloatEdge = ourMargin->mFloatEdge.GetIntValue(); } else if (eCSSUnit_Inherit == ourMargin->mFloatEdge.GetUnit()) { - spacing->mFloatEdge = parentSpacing->mFloatEdge; + border->mFloatEdge = parentBorder->mFloatEdge; } } } diff --git a/mozilla/layout/style/nsComputedDOMStyle.cpp b/mozilla/layout/style/nsComputedDOMStyle.cpp index 102170bf8b3..98898280bef 100644 --- a/mozilla/layout/style/nsComputedDOMStyle.cpp +++ b/mozilla/layout/style/nsComputedDOMStyle.cpp @@ -844,15 +844,15 @@ nsComputedDOMStyle::GetMargin(nsAWritableString& aMargin) nsresult GetMargins(nsIFrame *aFrame, nscoord& left, nscoord& top, nscoord& right, nscoord& bottom) { - const nsStyleSpacing* spacing; + const nsStyleBorder* border; nsStyleCoord coord; - frame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); + frame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + if (border) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); } } } @@ -1267,31 +1267,33 @@ nsComputedDOMStyle::GetAbsoluteFrameRect(nsIFrame *aFrame, nsRect& aRect) } // For the origin, add in the border for the frame - const nsStyleSpacing* spacing; + const nsStyleBorder* border; + const nsStylePadding* padding; nsStyleCoord coord; - aFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); - aRect.width -= spacing->mBorder.GetLeft(coord).GetCoordValue(); - //aRect.width -= spacing->mMargin.GetLeft(coord).GetCoordValue(); - aRect.width -= spacing->mPadding.GetLeft(coord).GetCoordValue(); + aFrame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + aFrame->GetStyleData(eStyleStruct_Padding, (const nsStyleStruct*&)padding); + if (border && padding) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); + aRect.width -= border->mBorder.GetLeft(coord).GetCoordValue(); + //aRect.width -= margin->mMargin.GetLeft(coord).GetCoordValue(); + aRect.width -= padding->mPadding.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); - aRect.height -= spacing->mBorder.GetTop(coord).GetCoordValue(); - //aRect.height -= spacing->mMargin.GetTop(coord).GetCoordValue(); - aRect.height -= spacing->mPadding.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); + aRect.height -= border->mBorder.GetTop(coord).GetCoordValue(); + //aRect.height -= margin->mMargin.GetTop(coord).GetCoordValue(); + aRect.height -= padding->mPadding.GetTop(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetRightUnit()) { - aRect.width -= spacing->mBorder.GetRight(coord).GetCoordValue(); - //aRect.width -= spacing->mMargin.GetRight(coord).GetCoordValue(); - aRect.width -= spacing->mPadding.GetRight(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetRightUnit()) { + aRect.width -= border->mBorder.GetRight(coord).GetCoordValue(); + //aRect.width -= margin->mMargin.GetRight(coord).GetCoordValue(); + aRect.width -= padding->mPadding.GetRight(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetBottomUnit()) { - aRect.height -= spacing->mBorder.GetBottom(coord).GetCoordValue(); - //aRect.height -= spacing->mMargin.GetBottom(coord).GetCoordValue(); - aRect.height -= spacing->mPadding.GetBottom(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetBottomUnit()) { + aRect.height -= border->mBorder.GetBottom(coord).GetCoordValue(); + //aRect.height -= margin->mMargin.GetBottom(coord).GetCoordValue(); + aRect.height -= padding->mPadding.GetBottom(coord).GetCoordValue(); } } diff --git a/mozilla/layout/style/nsHTMLCSSStyleSheet.cpp b/mozilla/layout/style/nsHTMLCSSStyleSheet.cpp index d4aba054254..0e501fa570f 100644 --- a/mozilla/layout/style/nsHTMLCSSStyleSheet.cpp +++ b/mozilla/layout/style/nsHTMLCSSStyleSheet.cpp @@ -132,13 +132,13 @@ CSSFirstLineRule::MapStyleInto(nsIMutableStyleContext* aContext, parentContext = aContext->GetParent(); // Disable border - nsStyleSpacing* spacing = (nsStyleSpacing*) - aContext->GetMutableStyleData(eStyleStruct_Spacing); - if (spacing) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + nsStyleBorder* border = (nsStyleBorder*) + aContext->GetMutableStyleData(eStyleStruct_Border); + if (border) { + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); } // Undo any change made to "direction" diff --git a/mozilla/layout/style/nsStyleContext.cpp b/mozilla/layout/style/nsStyleContext.cpp index f10e153777a..2c4f254771a 100644 --- a/mozilla/layout/style/nsStyleContext.cpp +++ b/mozilla/layout/style/nsStyleContext.cpp @@ -33,6 +33,7 @@ * 03/20/2000 IBM Corp. BiDi - ability to change the default direction of the browser * */ + #include "nsIStyleContext.h" #include "nsIMutableStyleContext.h" #include "nsStyleConsts.h" @@ -103,6 +104,26 @@ static nscoord CalcCoord(const nsStyleCoord& aCoord, const nscoord* aEnumTable, PRInt32 aNumEnums); +// XXX this is here to support deprecated calc spacing methods only +static nscoord kBorderWidths[3]; // contain the twips values for thin, medium and thick +static void InitBorderWidths(nsIPresContext* aPresContext) +{ + // XXX support kBorderWidhts until deprecated methods are removed + static PRBool kWidthsInitialized = PR_FALSE; + if (! kWidthsInitialized) { + kWidthsInitialized = PR_TRUE; + + float pixelsToTwips = 20.0f; + if (aPresContext) { + aPresContext->GetPixelsToTwips(&pixelsToTwips); + } + kBorderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); + kBorderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); + kBorderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); + } +} + + // EnsureBlockDisplay: // - if the display value (argument) is not a block-type // then we set it to a valid block display value @@ -220,6 +241,10 @@ PRUint32 StyleFontImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleColor // @@ -348,14 +373,13 @@ PRUint32 StyleColorImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } -// -------------------- -// nsStyleSpacing -// -// XXX this is here to support deprecated calc spacing methods only -static nscoord kBorderWidths[3]; -static PRBool kWidthsInitialized = PR_FALSE; +#ifdef XP_MAC +#pragma mark - +#endif -nsStyleSpacing::nsStyleSpacing(void) { } +#define BORDER_COLOR_DEFINED 0x80 +#define BORDER_COLOR_SPECIAL 0x40 +#define BORDER_STYLE_MASK 0x3F #define NS_SPACING_MARGIN 0 #define NS_SPACING_PADDING 1 @@ -379,21 +403,26 @@ static nscoord CalcSideFor(const nsIFrame* aFrame, const nsStyleCoord& aCoord, nsIStyleContext* parentContext; parentFrame->GetStyleContext(&parentContext); if (nsnull != parentContext) { - const nsStyleSpacing* parentSpacing = (const nsStyleSpacing*)parentContext->GetStyleData(eStyleStruct_Spacing); - nsMargin parentMargin; + nsMargin parentSide; switch (aSpacing) { - case NS_SPACING_MARGIN: parentSpacing->CalcMarginFor(parentFrame, parentMargin); + case NS_SPACING_MARGIN: + const nsStyleMargin* parentMargin = (const nsStyleMargin*)parentContext->GetStyleData(eStyleStruct_Margin); + parentMargin->CalcMarginFor(parentFrame, parentSide); break; - case NS_SPACING_PADDING: parentSpacing->CalcPaddingFor(parentFrame, parentMargin); + case NS_SPACING_PADDING: + const nsStylePadding* parentPadding = (const nsStylePadding*)parentContext->GetStyleData(eStyleStruct_Padding); + parentPadding->CalcPaddingFor(parentFrame, parentSide); break; - case NS_SPACING_BORDER: parentSpacing->CalcBorderFor(parentFrame, parentMargin); + case NS_SPACING_BORDER: + const nsStyleBorder* parentBorder = (const nsStyleBorder*)parentContext->GetStyleData(eStyleStruct_Border); + parentBorder->CalcBorderFor(parentFrame, parentSide); break; } switch (aSide) { - case NS_SIDE_LEFT: result = parentMargin.left; break; - case NS_SIDE_TOP: result = parentMargin.top; break; - case NS_SIDE_RIGHT: result = parentMargin.right; break; - case NS_SIDE_BOTTOM: result = parentMargin.bottom; break; + case NS_SIDE_LEFT: result = parentSide.left; break; + case NS_SIDE_TOP: result = parentSide.top; break; + case NS_SIDE_RIGHT: result = parentSide.right; break; + case NS_SIDE_BOTTOM: result = parentSide.bottom; break; } NS_RELEASE(parentContext); } @@ -466,248 +495,6 @@ static void CalcSidesFor(const nsIFrame* aFrame, const nsStyleSides& aSides, aEnumTable, aNumEnums); } -void nsStyleSpacing::CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const -{ - if (mHasCachedMargin) { - aMargin = mCachedMargin; - } else { - CalcSidesFor(aFrame, mMargin, NS_SPACING_MARGIN, nsnull, 0, aMargin); - } -} - -void nsStyleSpacing::CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const -{ - if (mHasCachedPadding) { - aPadding = mCachedPadding; - } else { - CalcSidesFor(aFrame, mPadding, NS_SPACING_PADDING, nsnull, 0, aPadding); - } -} - -void nsStyleSpacing::CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const -{ - if (mHasCachedBorder) { - aBorder = mCachedBorder; - } else { - CalcSidesFor(aFrame, mBorder, NS_SPACING_BORDER, kBorderWidths, 3, aBorder); - } -} - -void nsStyleSpacing::CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const -{ - if (mHasCachedPadding && mHasCachedBorder) { - aBorderPadding = mCachedBorderPadding; - } else { - nsMargin border; - CalcBorderFor(aFrame, border); - CalcPaddingFor(aFrame, aBorderPadding); - aBorderPadding += border; - } -} - -PRBool nsStyleSpacing::GetMargin(nsMargin& aMargin) const -{ - if (mHasCachedMargin) { - aMargin = mCachedMargin; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetPadding(nsMargin& aPadding) const -{ - if (mHasCachedPadding) { - aPadding = mCachedPadding; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetBorder(nsMargin& aBorder) const -{ - if (mHasCachedBorder) { - aBorder = mCachedBorder; - return PR_TRUE; - } - return PR_FALSE; -} - -PRBool nsStyleSpacing::GetBorderPadding(nsMargin& aBorderPadding) const -{ - if (mHasCachedPadding && mHasCachedBorder) { - aBorderPadding = mCachedBorderPadding; - return PR_TRUE; - } - return PR_FALSE; -} - -#define BORDER_COLOR_DEFINED 0x80 -#define BORDER_COLOR_SPECIAL 0x40 -#define BORDER_STYLE_MASK 0x3F - - -PRUint8 nsStyleSpacing::GetBorderStyle(PRUint8 aSide) const -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - return (mBorderStyle[aSide] & BORDER_STYLE_MASK); -} - -void nsStyleSpacing::SetBorderStyle(PRUint8 aSide, PRUint8 aStyle) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] &= ~BORDER_STYLE_MASK; - mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK); - -} - -PRBool nsStyleSpacing::GetBorderColor(PRUint8 aSide, nscolor& aColor) const -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0) { - aColor = mBorderColor[aSide]; - return PR_TRUE; - } - return PR_FALSE; -} - -void nsStyleSpacing::SetBorderColor(PRUint8 aSide, nscolor aColor) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderColor[aSide] = aColor; - mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL; - mBorderStyle[aSide] |= BORDER_COLOR_DEFINED; -} - -void nsStyleSpacing::SetBorderTransparent(PRUint8 aSide) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); -} - -void nsStyleSpacing::UnsetBorderColor(PRUint8 aSide) -{ - NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); - mBorderStyle[aSide] &= BORDER_STYLE_MASK; -} - -PRBool nsStyleSpacing::GetOutlineWidth(nscoord& aWidth) const -{ - if (mHasCachedOutline) { - aWidth = mCachedOutlineWidth; - return PR_TRUE; - } - return PR_FALSE; -} - -PRUint8 nsStyleSpacing::GetOutlineStyle(void) const -{ - return (mOutlineStyle & BORDER_STYLE_MASK); -} - -void nsStyleSpacing::SetOutlineStyle(PRUint8 aStyle) -{ - mOutlineStyle &= ~BORDER_STYLE_MASK; - mOutlineStyle |= (aStyle & BORDER_STYLE_MASK); -} - -PRBool nsStyleSpacing::GetOutlineColor(nscolor& aColor) const -{ - if ((mOutlineStyle & BORDER_COLOR_SPECIAL) == 0) { - aColor = mOutlineColor; - return PR_TRUE; - } - return PR_FALSE; -} - -void nsStyleSpacing::SetOutlineColor(nscolor aColor) -{ - mOutlineColor = aColor; - mOutlineStyle &= ~BORDER_COLOR_SPECIAL; - mOutlineStyle |= BORDER_COLOR_DEFINED; -} - -void nsStyleSpacing::SetOutlineInvert(void) -{ - mOutlineStyle |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); -} - - - -struct StyleSpacingImpl: public nsStyleSpacing { - StyleSpacingImpl(void) - : nsStyleSpacing() - {} - - void ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext); - void SetFrom(const nsStyleSpacing& aSource); - void CopyTo(nsStyleSpacing& aDest) const; - PRBool IsBorderSideVisible(PRUint8 aSide) const; - void RecalcData(nsIPresContext* aPresContext, nscolor color); - PRInt32 CalcDifference(const StyleSpacingImpl& aOther) const; - PRUint32 ComputeCRC32(PRUint32 aCrc) const; - -}; - -void StyleSpacingImpl::ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext) -{ - // XXX support kBorderWidhts until deprecated methods are removed - if (! kWidthsInitialized) { - float pixelsToTwips = 20.0f; - if (aPresContext) { - aPresContext->GetPixelsToTwips(&pixelsToTwips); - } - kBorderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); - kBorderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); - kBorderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); - kWidthsInitialized = PR_TRUE; - } - - - // spacing values not inherited - mMargin.Reset(); - mPadding.Reset(); - nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); - mBorder.SetLeft(medium); - mBorder.SetTop(medium); - mBorder.SetRight(medium); - mBorder.SetBottom(medium); - - mBorderStyle[0] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[1] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[2] = NS_STYLE_BORDER_STYLE_NONE; - mBorderStyle[3] = NS_STYLE_BORDER_STYLE_NONE; - - - mBorderColor[0] = NS_RGB(0, 0, 0); - mBorderColor[1] = NS_RGB(0, 0, 0); - mBorderColor[2] = NS_RGB(0, 0, 0); - mBorderColor[3] = NS_RGB(0, 0, 0); - - mBorderRadius.Reset(); - mOutlineRadius.Reset(); - - mOutlineWidth = medium; - mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE; - mOutlineColor = NS_RGB(0, 0, 0); - - mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT; - - mHasCachedMargin = PR_FALSE; - mHasCachedPadding = PR_FALSE; - mHasCachedBorder = PR_FALSE; - mHasCachedOutline = PR_FALSE; -} - -void StyleSpacingImpl::SetFrom(const nsStyleSpacing& aSource) -{ - nsCRT::memcpy((nsStyleSpacing*)this, &aSource, sizeof(nsStyleSpacing)); -} - -void StyleSpacingImpl::CopyTo(nsStyleSpacing& aDest) const -{ - nsCRT::memcpy(&aDest, (const nsStyleSpacing*)this, sizeof(nsStyleSpacing)); -} - static PRBool IsFixedData(const nsStyleSides& aSides, PRBool aEnumOK) { return PRBool(IsFixedUnit(aSides.GetLeftUnit(), aEnumOK) && @@ -740,24 +527,64 @@ static nscoord CalcCoord(const nsStyleCoord& aCoord, return 0; } -PRBool StyleSpacingImpl::IsBorderSideVisible(PRUint8 aSide) const + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleMargin::nsStyleMargin(void) { } + +PRBool nsStyleMargin::GetMargin(nsMargin& aMargin) const { - PRUint8 borderStyle = GetBorderStyle(aSide); - return ((borderStyle != NS_STYLE_BORDER_STYLE_NONE) - && (borderStyle != NS_STYLE_BORDER_STYLE_HIDDEN)); + if (mHasCachedMargin) { + aMargin = mCachedMargin; + return PR_TRUE; + } + return PR_FALSE; } -void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) +void nsStyleMargin::CalcMarginFor(const nsIFrame* aFrame, nsMargin& aMargin) const { - nscoord borderWidths[3]; - float pixelsToTwips = 20.0f; - if (aPresContext) { - aPresContext->GetPixelsToTwips(&pixelsToTwips); + if (mHasCachedMargin) { + aMargin = mCachedMargin; + } else { + CalcSidesFor(aFrame, mMargin, NS_SPACING_MARGIN, nsnull, 0, aMargin); } - borderWidths[NS_STYLE_BORDER_WIDTH_THIN] = NSIntPixelsToTwips(1, pixelsToTwips); - borderWidths[NS_STYLE_BORDER_WIDTH_MEDIUM] = NSIntPixelsToTwips(3, pixelsToTwips); - borderWidths[NS_STYLE_BORDER_WIDTH_THICK] = NSIntPixelsToTwips(5, pixelsToTwips); +} +struct StyleMarginImpl: public nsStyleMargin { + StyleMarginImpl(void) + : nsStyleMargin() + {} + + void ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleMargin& aSource); + void CopyTo(nsStyleMargin& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StyleMarginImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleMarginImpl::ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mMargin.Reset(); + mHasCachedMargin = PR_FALSE; +} + +void StyleMarginImpl::SetFrom(const nsStyleMargin& aSource) +{ + nsCRT::memcpy((nsStyleMargin*)this, &aSource, sizeof(nsStyleMargin)); +} + +void StyleMarginImpl::CopyTo(nsStyleMargin& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleMargin*)this, sizeof(nsStyleMargin)); +} + +void StyleMarginImpl::RecalcData(void) +{ if (IsFixedData(mMargin, PR_FALSE)) { nsStyleCoord coord; mCachedMargin.left = CalcCoord(mMargin.GetLeft(coord), nsnull, 0); @@ -770,7 +597,86 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) else { mHasCachedMargin = PR_FALSE; } +} +PRInt32 StyleMarginImpl::CalcDifference(const StyleMarginImpl& aOther) const +{ + if (mMargin == aOther.mMargin) { + return NS_STYLE_HINT_NONE; + } + return NS_STYLE_HINT_REFLOW; +} + +PRUint32 StyleMarginImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mMargin); + crc = AccumulateCRC(crc,(const char *)&mHasCachedMargin,sizeof(mHasCachedMargin)); + crc = StyleMarginCRC(crc,&mCachedMargin); +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStylePadding::nsStylePadding(void) { } + +PRBool nsStylePadding::GetPadding(nsMargin& aPadding) const +{ + if (mHasCachedPadding) { + aPadding = mCachedPadding; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStylePadding::CalcPaddingFor(const nsIFrame* aFrame, nsMargin& aPadding) const +{ + if (mHasCachedPadding) { + aPadding = mCachedPadding; + } else { + CalcSidesFor(aFrame, mPadding, NS_SPACING_PADDING, nsnull, 0, aPadding); + } +} + +struct StylePaddingImpl: public nsStylePadding { + StylePaddingImpl(void) + : nsStylePadding() + {} + + void ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStylePadding& aSource); + void CopyTo(nsStylePadding& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StylePaddingImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StylePaddingImpl::ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mPadding.Reset(); + mHasCachedPadding = PR_FALSE; +} + +void StylePaddingImpl::SetFrom(const nsStylePadding& aSource) +{ + nsCRT::memcpy((nsStylePadding*)this, &aSource, sizeof(nsStylePadding)); +} + +void StylePaddingImpl::CopyTo(nsStylePadding& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStylePadding*)this, sizeof(nsStylePadding)); +} + +void StylePaddingImpl::RecalcData(void) +{ if (IsFixedData(mPadding, PR_FALSE)) { nsStyleCoord coord; mCachedPadding.left = CalcCoord(mPadding.GetLeft(coord), nsnull, 0); @@ -783,7 +689,177 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) else { mHasCachedPadding = PR_FALSE; } +} +PRInt32 StylePaddingImpl::CalcDifference(const StylePaddingImpl& aOther) const +{ + if (mPadding == aOther.mPadding) { + return NS_STYLE_HINT_NONE; + } + return NS_STYLE_HINT_REFLOW; +} + +PRUint32 StylePaddingImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mPadding); + crc = AccumulateCRC(crc,(const char *)&mHasCachedPadding,sizeof(mHasCachedPadding)); + crc = StyleMarginCRC(crc,&mCachedPadding); +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleBorderPadding::nsStyleBorderPadding(void) { mHasCachedBorderPadding = PR_FALSE; } + +PRBool nsStyleBorderPadding::GetBorderPadding(nsMargin& aBorderPadding) const { + if (mHasCachedBorderPadding) { + aBorderPadding = mCachedBorderPadding; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleBorderPadding::SetBorderPadding(nsMargin aBorderPadding) { + mCachedBorderPadding = aBorderPadding; + mHasCachedBorderPadding = PR_TRUE; +} + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleBorder::nsStyleBorder(void) { } + +PRBool nsStyleBorder::GetBorder(nsMargin& aBorder) const +{ + if (mHasCachedBorder) { + aBorder = mCachedBorder; + return PR_TRUE; + } + return PR_FALSE; +} + +PRUint8 nsStyleBorder::GetBorderStyle(PRUint8 aSide) const +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + return (mBorderStyle[aSide] & BORDER_STYLE_MASK); +} + +void nsStyleBorder::SetBorderStyle(PRUint8 aSide, PRUint8 aStyle) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] &= ~BORDER_STYLE_MASK; + mBorderStyle[aSide] |= (aStyle & BORDER_STYLE_MASK); + +} + +PRBool nsStyleBorder::GetBorderColor(PRUint8 aSide, nscolor& aColor) const +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + if ((mBorderStyle[aSide] & BORDER_COLOR_SPECIAL) == 0) { + aColor = mBorderColor[aSide]; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleBorder::SetBorderColor(PRUint8 aSide, nscolor aColor) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderColor[aSide] = aColor; + mBorderStyle[aSide] &= ~BORDER_COLOR_SPECIAL; + mBorderStyle[aSide] |= BORDER_COLOR_DEFINED; +} + +void nsStyleBorder::SetBorderTransparent(PRUint8 aSide) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); +} + +void nsStyleBorder::UnsetBorderColor(PRUint8 aSide) +{ + NS_ASSERTION(aSide <= NS_SIDE_LEFT, "bad side"); + mBorderStyle[aSide] &= BORDER_STYLE_MASK; +} + +void nsStyleBorder::CalcBorderFor(const nsIFrame* aFrame, nsMargin& aBorder) const +{ + if (mHasCachedBorder) { + aBorder = mCachedBorder; + } else { + CalcSidesFor(aFrame, mBorder, NS_SPACING_BORDER, kBorderWidths, 3, aBorder); + } +} + +struct StyleBorderImpl: public nsStyleBorder { + StyleBorderImpl(void) + : nsStyleBorder() + {} + + void ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleBorder& aSource); + void CopyTo(nsStyleBorder& aDest) const; + PRBool IsBorderSideVisible(PRUint8 aSide) const; + void RecalcData(nscolor color); + PRInt32 CalcDifference(const StyleBorderImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleBorderImpl::ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); + mBorder.SetLeft(medium); + mBorder.SetTop(medium); + mBorder.SetRight(medium); + mBorder.SetBottom(medium); + + mBorderStyle[0] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[1] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[2] = NS_STYLE_BORDER_STYLE_NONE; + mBorderStyle[3] = NS_STYLE_BORDER_STYLE_NONE; + + + mBorderColor[0] = NS_RGB(0, 0, 0); + mBorderColor[1] = NS_RGB(0, 0, 0); + mBorderColor[2] = NS_RGB(0, 0, 0); + mBorderColor[3] = NS_RGB(0, 0, 0); + + mBorderRadius.Reset(); + + mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT; + + mHasCachedBorder = PR_FALSE; +} + +void StyleBorderImpl::SetFrom(const nsStyleBorder& aSource) +{ + nsCRT::memcpy((nsStyleBorder*)this, &aSource, sizeof(nsStyleBorder)); +} + +void StyleBorderImpl::CopyTo(nsStyleBorder& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleBorder*)this, sizeof(nsStyleBorder)); +} + +PRBool StyleBorderImpl::IsBorderSideVisible(PRUint8 aSide) const +{ + PRUint8 borderStyle = GetBorderStyle(aSide); + return ((borderStyle != NS_STYLE_BORDER_STYLE_NONE) + && (borderStyle != NS_STYLE_BORDER_STYLE_HIDDEN)); +} + +void StyleBorderImpl::RecalcData(nscolor aColor) +{ if (((!IsBorderSideVisible(NS_SIDE_LEFT))|| IsFixedUnit(mBorder.GetLeftUnit(), PR_TRUE)) && ((!IsBorderSideVisible(NS_SIDE_TOP)) || @@ -797,25 +873,25 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) mCachedBorder.left = 0; } else { - mCachedBorder.left = CalcCoord(mBorder.GetLeft(coord), borderWidths, 3); + mCachedBorder.left = CalcCoord(mBorder.GetLeft(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_TOP)) { mCachedBorder.top = 0; } else { - mCachedBorder.top = CalcCoord(mBorder.GetTop(coord), borderWidths, 3); + mCachedBorder.top = CalcCoord(mBorder.GetTop(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_RIGHT)) { mCachedBorder.right = 0; } else { - mCachedBorder.right = CalcCoord(mBorder.GetRight(coord), borderWidths, 3); + mCachedBorder.right = CalcCoord(mBorder.GetRight(coord), kBorderWidths, 3); } if (!IsBorderSideVisible(NS_SIDE_BOTTOM)) { mCachedBorder.bottom = 0; } else { - mCachedBorder.bottom = CalcCoord(mBorder.GetBottom(coord), borderWidths, 3); + mCachedBorder.bottom = CalcCoord(mBorder.GetBottom(coord), kBorderWidths, 3); } mHasCachedBorder = PR_TRUE; } @@ -823,11 +899,6 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) mHasCachedBorder = PR_FALSE; } - if (mHasCachedBorder && mHasCachedPadding) { - mCachedBorderPadding = mCachedPadding; - mCachedBorderPadding += mCachedBorder; - } - if ((mBorderStyle[NS_SIDE_TOP] & BORDER_COLOR_DEFINED) == 0) { mBorderColor[NS_SIDE_TOP] = aColor; } @@ -840,27 +911,11 @@ void StyleSpacingImpl::RecalcData(nsIPresContext* aPresContext, nscolor aColor) if ((mBorderStyle[NS_SIDE_RIGHT] & BORDER_COLOR_DEFINED) == 0) { mBorderColor[NS_SIDE_RIGHT] = aColor; } - - if ((NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) || - IsFixedUnit(mOutlineWidth.GetUnit(), PR_TRUE)) { - if (NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) { - mCachedOutlineWidth = 0; - } - else { - mCachedOutlineWidth = CalcCoord(mOutlineWidth, borderWidths, 3); - } - mHasCachedOutline = PR_TRUE; - } - else { - mHasCachedOutline = PR_FALSE; - } } -PRInt32 StyleSpacingImpl::CalcDifference(const StyleSpacingImpl& aOther) const +PRInt32 StyleBorderImpl::CalcDifference(const StyleBorderImpl& aOther) const { - if ((mMargin == aOther.mMargin) && - (mPadding == aOther.mPadding) && - (mBorder == aOther.mBorder) && + if ((mBorder == aOther.mBorder) && (mFloatEdge == aOther.mFloatEdge)) { PRInt32 ix; for (ix = 0; ix < 4; ix++) { @@ -879,46 +934,158 @@ PRInt32 StyleSpacingImpl::CalcDifference(const StyleSpacingImpl& aOther) const if (mBorderRadius != aOther.mBorderRadius) { return NS_STYLE_HINT_VISUAL; } - if ((mOutlineWidth != aOther.mOutlineWidth) || - (mOutlineStyle != aOther.mOutlineStyle) || - (mOutlineColor != aOther.mOutlineColor) || - (mOutlineRadius != aOther.mOutlineRadius)) { - return NS_STYLE_HINT_VISUAL; // XXX: should be VISUAL: see bugs 9809 and 9816 - } return NS_STYLE_HINT_NONE; } return NS_STYLE_HINT_REFLOW; } -PRUint32 StyleSpacingImpl::ComputeCRC32(PRUint32 aCrc) const +PRUint32 StyleBorderImpl::ComputeCRC32(PRUint32 aCrc) const { PRUint32 crc = aCrc; #ifdef COMPUTE_STYLEDATA_CRC - crc = StyleSideCRC(crc,&mMargin); - crc = StyleSideCRC(crc,&mPadding); crc = StyleSideCRC(crc,&mBorder); crc = StyleSideCRC(crc,&mBorderRadius); - crc = StyleSideCRC(crc,&mOutlineRadius); - crc = StyleCoordCRC(crc,&mOutlineWidth); crc = AccumulateCRC(crc,(const char *)&mFloatEdge,sizeof(mFloatEdge)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedMargin,sizeof(mHasCachedMargin)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedPadding,sizeof(mHasCachedPadding)); crc = AccumulateCRC(crc,(const char *)&mHasCachedBorder,sizeof(mHasCachedBorder)); - crc = AccumulateCRC(crc,(const char *)&mHasCachedOutline,sizeof(mHasCachedOutline)); - crc = StyleMarginCRC(crc,&mCachedMargin); - crc = StyleMarginCRC(crc,&mCachedPadding); crc = StyleMarginCRC(crc,&mCachedBorder); - crc = StyleMarginCRC(crc,&mCachedBorderPadding); - crc = AccumulateCRC(crc,(const char *)&mCachedOutlineWidth,sizeof(mCachedOutlineWidth)); crc = AccumulateCRC(crc,(const char *)mBorderStyle,sizeof(mBorderStyle)); // array of 4 elements crc = AccumulateCRC(crc,(const char *)mBorderColor,sizeof(mBorderColor)); // array ... +#endif + return crc; +} + + +#ifdef XP_MAC +#pragma mark - +#endif + +nsStyleOutline::nsStyleOutline(void) { } + +PRBool nsStyleOutline::GetOutlineWidth(nscoord& aWidth) const +{ + if (mHasCachedOutline) { + aWidth = mCachedOutlineWidth; + return PR_TRUE; + } + return PR_FALSE; +} + +PRUint8 nsStyleOutline::GetOutlineStyle(void) const +{ + return (mOutlineStyle & BORDER_STYLE_MASK); +} + +void nsStyleOutline::SetOutlineStyle(PRUint8 aStyle) +{ + mOutlineStyle &= ~BORDER_STYLE_MASK; + mOutlineStyle |= (aStyle & BORDER_STYLE_MASK); +} + +PRBool nsStyleOutline::GetOutlineColor(nscolor& aColor) const +{ + if ((mOutlineStyle & BORDER_COLOR_SPECIAL) == 0) { + aColor = mOutlineColor; + return PR_TRUE; + } + return PR_FALSE; +} + +void nsStyleOutline::SetOutlineColor(nscolor aColor) +{ + mOutlineColor = aColor; + mOutlineStyle &= ~BORDER_COLOR_SPECIAL; + mOutlineStyle |= BORDER_COLOR_DEFINED; +} + +void nsStyleOutline::SetOutlineInvert(void) +{ + mOutlineStyle |= (BORDER_COLOR_DEFINED | BORDER_COLOR_SPECIAL); +} + +struct StyleOutlineImpl: public nsStyleOutline { + StyleOutlineImpl(void) + : nsStyleOutline() + {} + + void ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext); + void SetFrom(const nsStyleOutline& aSource); + void CopyTo(nsStyleOutline& aDest) const; + void RecalcData(void); + PRInt32 CalcDifference(const StyleOutlineImpl& aOther) const; + PRUint32 ComputeCRC32(PRUint32 aCrc) const; + +}; + +void StyleOutlineImpl::ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext) +{ + // spacing values not inherited + mOutlineRadius.Reset(); + + nsStyleCoord medium(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated); + mOutlineWidth = medium; + mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE; + mOutlineColor = NS_RGB(0, 0, 0); + + mHasCachedOutline = PR_FALSE; +} + +void StyleOutlineImpl::SetFrom(const nsStyleOutline& aSource) +{ + nsCRT::memcpy((nsStyleOutline*)this, &aSource, sizeof(nsStyleOutline)); +} + +void StyleOutlineImpl::CopyTo(nsStyleOutline& aDest) const +{ + nsCRT::memcpy(&aDest, (const nsStyleOutline*)this, sizeof(nsStyleOutline)); +} + +void StyleOutlineImpl::RecalcData(void) +{ + if ((NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) || + IsFixedUnit(mOutlineWidth.GetUnit(), PR_TRUE)) { + if (NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) { + mCachedOutlineWidth = 0; + } + else { + mCachedOutlineWidth = CalcCoord(mOutlineWidth, kBorderWidths, 3); + } + mHasCachedOutline = PR_TRUE; + } + else { + mHasCachedOutline = PR_FALSE; + } +} + +PRInt32 StyleOutlineImpl::CalcDifference(const StyleOutlineImpl& aOther) const +{ + if ((mOutlineWidth != aOther.mOutlineWidth) || + (mOutlineStyle != aOther.mOutlineStyle) || + (mOutlineColor != aOther.mOutlineColor) || + (mOutlineRadius != aOther.mOutlineRadius)) { + return NS_STYLE_HINT_VISUAL; // XXX: should be VISUAL: see bugs 9809 and 9816 + } + return NS_STYLE_HINT_NONE; +} + +PRUint32 StyleOutlineImpl::ComputeCRC32(PRUint32 aCrc) const +{ + PRUint32 crc = aCrc; + +#ifdef COMPUTE_STYLEDATA_CRC + crc = StyleSideCRC(crc,&mOutlineRadius); + crc = StyleCoordCRC(crc,&mOutlineWidth); + crc = AccumulateCRC(crc,(const char *)&mHasCachedOutline,sizeof(mHasCachedOutline)); + crc = AccumulateCRC(crc,(const char *)&mCachedOutlineWidth,sizeof(mCachedOutlineWidth)); crc = AccumulateCRC(crc,(const char *)&mOutlineStyle,sizeof(mOutlineStyle)); crc = AccumulateCRC(crc,(const char *)&mOutlineColor,sizeof(mOutlineColor)); #endif return crc; } +#ifdef XP_MAC +#pragma mark - +#endif // -------------------- // nsStyleList // @@ -988,6 +1155,10 @@ PRUint32 StyleListImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStylePosition // @@ -1073,6 +1244,10 @@ PRUint32 StylePositionImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleText // @@ -1172,6 +1347,10 @@ PRUint32 StyleTextImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleDisplay // @@ -1285,6 +1464,10 @@ PRUint32 StyleDisplayImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif + // -------------------- // nsStyleTable // @@ -1393,6 +1576,9 @@ PRUint32 StyleTableImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStyleContent @@ -1754,6 +1940,9 @@ PRUint32 StyleContentImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStyleUserInterface @@ -1861,6 +2050,9 @@ PRUint32 StyleUserInterfaceImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //----------------------- // nsStylePrint @@ -1953,6 +2145,9 @@ PRUint32 StylePrintImpl::ComputeCRC32(PRUint32 aCrc) const return crc; } +#ifdef XP_MAC +#pragma mark - +#endif //---------------------------------------------------------------------- @@ -1997,20 +2192,6 @@ void StyleColorImplLog::ResetFrom(const nsStyleColor* aParent, nsIPresContext* a mSetFromParent = (aParent != nsnull); } -// StyleSpacingImpl mSpacing; -struct StyleSpacingImplLog: public StyleSpacingImpl { - void ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext); - StyleSpacingImpl mInternalSpacing; - bool mSetFromParent; -}; - -void StyleSpacingImplLog::ResetFrom(const nsStyleSpacing* aParent, nsIPresContext* aPresContext) -{ - StyleSpacingImpl::ResetFrom(aParent, aPresContext); - CopyTo(mInternalSpacing); - mSetFromParent = (aParent != nsnull); -} - // StyleListImpl mList; struct StyleListImplLog: public StyleListImpl { void ResetFrom(const nsStyleList* aParent, nsIPresContext* aPresContext); @@ -2123,6 +2304,65 @@ void StylePrintImplLog::ResetFrom(const nsStylePrint* aParent, nsIPresContext* a mSetFromParent = (aParent != nsnull); } +// StyleMarginImpl mMargin; +struct StyleMarginImplLog: public StyleMarginImpl { + void ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext); + StyleMarginImpl mInternalMargin; + bool mSetFromParent; +}; + +void StyleMarginImplLog::ResetFrom(const nsStyleMargin* aParent, nsIPresContext* aPresContext) +{ + StyleMarginImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalMargin); + mSetFromParent = (aParent != nsnull); +} + +// StylePaddingImpl mPadding; +struct StylePaddingImplLog: public StylePaddingImpl { + void ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext); + StylePaddingImpl mInternalPadding; + bool mSetFromParent; +}; + +void StylePaddingImplLog::ResetFrom(const nsStylePadding* aParent, nsIPresContext* aPresContext) +{ + StylePaddingImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalPadding); + mSetFromParent = (aParent != nsnull); +} + +// StyleBorderImpl mBorder; +struct StyleBorderImplLog: public StyleBorderImpl { + void ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext); + StyleBorderImpl mInternalBorder; + bool mSetFromParent; +}; + +void StyleBorderImplLog::ResetFrom(const nsStyleBorder* aParent, nsIPresContext* aPresContext) +{ + StyleBorderImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalBorder); + mSetFromParent = (aParent != nsnull); +} + +// StyleOutlineImpl mOutline; +struct StyleOutlineImplLog: public StyleOutlineImpl { + void ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext); + StyleOutlineImpl mInternalOutline; + bool mSetFromParent; +}; + +void StyleOutlineImplLog::ResetFrom(const nsStyleOutline* aParent, nsIPresContext* aPresContext) +{ + StyleOutlineImpl::ResetFrom(aParent, aPresContext); + CopyTo(mInternalOutline); + mSetFromParent = (aParent != nsnull); +} + +#ifdef XP_MAC +#pragma mark - +#endif #endif // LOG_STYLE_STRUCTS //======================== @@ -2159,7 +2399,6 @@ private: // all data and methods private: only friends have access #ifdef LOG_STYLE_STRUCTS StyleFontImplLog mFont; StyleColorImplLog mColor; - StyleSpacingImplLog mSpacing; StyleListImplLog mList; StylePositionImplLog mPosition; StyleTextImplLog mText; @@ -2168,10 +2407,13 @@ private: // all data and methods private: only friends have access StyleContentImplLog mContent; StyleUserInterfaceImplLog mUserInterface; StylePrintImplLog mPrint; + StyleMarginImplLog mMargin; + StylePaddingImplLog mPadding; + StyleBorderImplLog mBorder; + StyleOutlineImplLog mOutline; #else StyleFontImpl mFont; StyleColorImpl mColor; - StyleSpacingImpl mSpacing; StyleListImpl mList; StylePositionImpl mPosition; StyleTextImpl mText; @@ -2180,6 +2422,10 @@ private: // all data and methods private: only friends have access StyleContentImpl mContent; StyleUserInterfaceImpl mUserInterface; StylePrintImpl mPrint; + StyleMarginImpl mMargin; + StylePaddingImpl mPadding; + StyleBorderImpl mBorder; + StyleOutlineImpl mOutline; #endif PRUint32 mRefCnt; @@ -2277,7 +2523,7 @@ static bool IsTimeToDumpStyleStructs() } static void LogStyleStructs(nsStyleContextData* aStyleContextData) { -#define max_structs eStyleStruct_Print +#define max_structs eStyleStruct_Max static unsigned long totalCount = 0; static unsigned long defaultStruct[max_structs]; @@ -2302,7 +2548,6 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) switch (index) { case eStyleStruct_Font: printf("eStyleStruct_Font "); sizeOfStruct = sizeof(StyleFontImpl); break; case eStyleStruct_Color: printf("eStyleStruct_Color "); sizeOfStruct = sizeof(StyleColorImpl); break; - case eStyleStruct_Spacing: printf("eStyleStruct_Spacing "); sizeOfStruct = sizeof(StyleSpacingImpl); break; case eStyleStruct_List: printf("eStyleStruct_List "); sizeOfStruct = sizeof(StyleListImpl); break; case eStyleStruct_Position: printf("eStyleStruct_Position "); sizeOfStruct = sizeof(StylePositionImpl); break; case eStyleStruct_Text: printf("eStyleStruct_Text "); sizeOfStruct = sizeof(StyleTextImpl); break; @@ -2311,6 +2556,10 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) case eStyleStruct_Content: printf("eStyleStruct_Content "); sizeOfStruct = sizeof(StyleContentImpl); break; case eStyleStruct_UserInterface: printf("eStyleStruct_UserInterface "); sizeOfStruct = sizeof(StyleUserInterfaceImpl); break; case eStyleStruct_Print: printf("eStyleStruct_Print "); sizeOfStruct = sizeof(StylePrintImpl); break; + case eStyleStruct_Margin: printf("eStyleStruct_Margin "); sizeOfStruct = sizeof(StyleMarginImpl); break; + case eStyleStruct_Padding: printf("eStyleStruct_Padding "); sizeOfStruct = sizeof(StylePaddingImpl); break; + case eStyleStruct_Border: printf("eStyleStruct_Border "); sizeOfStruct = sizeof(StyleBorderImpl); break; + case eStyleStruct_Outline: printf("eStyleStruct_Outline "); sizeOfStruct = sizeof(StyleOutlineImpl); break; } short percentDefault = (totalCount == 0 ? 0 : ((100 * defaultStruct[i]) / totalCount)); short percentFromParent = (defaultStruct[i] == 0 ? 0 : ((100 * setFromParent[i]) / defaultStruct[i])); @@ -2366,13 +2615,6 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) setFromParent[i]++; } break; - case eStyleStruct_Spacing: - if (aStyleContextData->mSpacing.CalcDifference(aStyleContextData->mSpacing.mInternalSpacing) == NS_STYLE_HINT_NONE) { - defaultStruct[i]++; - if (aStyleContextData->mSpacing.mSetFromParent) - setFromParent[i]++; - } - break; case eStyleStruct_List: if (aStyleContextData->mList.CalcDifference(aStyleContextData->mList.mInternalList) == NS_STYLE_HINT_NONE) { defaultStruct[i]++; @@ -2429,6 +2671,34 @@ static void LogStyleStructs(nsStyleContextData* aStyleContextData) setFromParent[i]++; } break; + case eStyleStruct_Margin: + if (aStyleContextData->mMargin.CalcDifference(aStyleContextData->mMargin.mInternalMargin) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mMargin.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Padding: + if (aStyleContextData->mPadding.CalcDifference(aStyleContextData->mPadding.mInternalPadding) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mPadding.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Border: + if (aStyleContextData->mBorder.CalcDifference(aStyleContextData->mBorder.mInternalBorder) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mBorder.mSetFromParent) + setFromParent[i]++; + } + break; + case eStyleStruct_Outline: + if (aStyleContextData->mOutline.CalcDifference(aStyleContextData->mOutline.mInternalOutline) == NS_STYLE_HINT_NONE) { + defaultStruct[i]++; + if (aStyleContextData->mOutline.mSetFromParent) + setFromParent[i]++; + } + break; } } @@ -2463,7 +2733,6 @@ PRUint32 nsStyleContextData::ComputeCRC32(PRUint32 aCrc) const // have each style struct compute its own CRC, propogating the previous value... crc = mFont.ComputeCRC32(crc); crc = mColor.ComputeCRC32(crc); - crc = mSpacing.ComputeCRC32(crc); crc = mList.ComputeCRC32(crc); crc = mPosition.ComputeCRC32(crc); crc = mText.ComputeCRC32(crc); @@ -2472,6 +2741,10 @@ PRUint32 nsStyleContextData::ComputeCRC32(PRUint32 aCrc) const crc = mContent.ComputeCRC32(crc); crc = mUserInterface.ComputeCRC32(crc); crc = mPrint.ComputeCRC32(crc); + crc = mMargin.ComputeCRC32(crc); + crc = mPadding.ComputeCRC32(crc); + crc = mBorder.ComputeCRC32(crc); + crc = mOutline.ComputeCRC32(crc); #else crc = 0; #endif @@ -2535,6 +2808,7 @@ public: virtual void ForceUnique(void); virtual void RecalcAutomaticData(nsIPresContext* aPresContext); + virtual void CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const; NS_IMETHOD CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PRBool aStopAtFirstDifference = PR_FALSE) const; #ifdef SHARE_STYLECONTEXTS @@ -2596,7 +2870,6 @@ protected: // the style data... StyleFontImpl mFont; StyleColorImpl mColor; - StyleSpacingImpl mSpacing; StyleListImpl mList; StylePositionImpl mPosition; StyleTextImpl mText; @@ -2605,6 +2878,10 @@ protected: StyleContentImpl mContent; StyleUserInterfaceImpl mUserInterface; StylePrintImpl mPrint; + StyleMarginImpl mMargin; + StylePaddingImpl mPadding; + StyleBorderImpl mBorder; + StyleOutlineImpl mOutline; #endif // #ifdef SHARE_STYLECONTEXTS @@ -2623,6 +2900,10 @@ static PRBool HashStyleRule(nsISupports* aRule, void* aData) return PR_TRUE; } +#ifdef XP_MAC +#pragma mark - +#endif + StyleContextImpl::StyleContextImpl(nsIStyleContext* aParent, nsIAtom* aPseudoTag, nsISupportsArray* aRules, @@ -2653,6 +2934,8 @@ StyleContextImpl::StyleContextImpl(nsIStyleContext* aParent, NS_IF_ADDREF(mPseudoTag); NS_IF_ADDREF(mRules); + InitBorderWidths(aPresContext); + mNextSibling = this; mPrevSibling = this; if (nsnull != mParent) { @@ -2916,7 +3199,9 @@ PRUint32 StyleContextImpl::HashValue(void) const //========================================================================================================= #ifdef DEBUG -//#define LOG_GET_STYLE_DATA_CALLS // define this to get stats on the calls to GetStyleData() //XXX pierre +// define this to get statistics on the number of calls +// to GetStyleData() and their depth in the Style tree. +//#define LOG_GET_STYLE_DATA_CALLS //XXX pierre #endif #ifdef LOG_GET_STYLE_DATA_CALLS @@ -2995,7 +3280,6 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon switch (i%max_structs + 1) { case eStyleStruct_Font: printf("eStyleStruct_Font "); break; case eStyleStruct_Color: printf("eStyleStruct_Color "); break; - case eStyleStruct_Spacing: printf("eStyleStruct_Spacing "); break; case eStyleStruct_List: printf("eStyleStruct_List "); break; case eStyleStruct_Position: printf("eStyleStruct_Position "); break; case eStyleStruct_Text: printf("eStyleStruct_Text "); break; @@ -3004,6 +3288,10 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon case eStyleStruct_Content: printf("eStyleStruct_Content "); break; case eStyleStruct_UserInterface: printf("eStyleStruct_UserInterface "); break; case eStyleStruct_Print: printf("eStyleStruct_Print "); break; + case eStyleStruct_Margin: printf("eStyleStruct_Margin "); break; + case eStyleStruct_Padding: printf("eStyleStruct_Padding "); break; + case eStyleStruct_Border: printf("eStyleStruct_Border "); break; + case eStyleStruct_Outline: printf("eStyleStruct_Outline "); break; } short percent = 100*calls[i]/totalCalls; short avdepth = calls[i] == 0 ? 0 : round(float(depth[i])/float(calls[i])); @@ -3076,7 +3364,6 @@ static void LogGetStyleDataCall(nsStyleStructID aSID, bool aMutable, nsIStyleCon #endif // LOG_GET_STYLE_DATA_CALLS //========================================================================================================= - const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) { #ifdef LOG_GET_STYLE_DATA_CALLS @@ -3092,9 +3379,6 @@ const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) case eStyleStruct_Color: result = & GETSCDATA(Color); break; - case eStyleStruct_Spacing: - result = & GETSCDATA(Spacing); - break; case eStyleStruct_List: result = & GETSCDATA(List); break; @@ -3119,6 +3403,18 @@ const nsStyleStruct* StyleContextImpl::GetStyleData(nsStyleStructID aSID) case eStyleStruct_Print: result = & GETSCDATA(Print); break; + case eStyleStruct_Margin: + result = & GETSCDATA(Margin); + break; + case eStyleStruct_Padding: + result = & GETSCDATA(Padding); + break; + case eStyleStruct_Border: + result = & GETSCDATA(Border); + break; + case eStyleStruct_Outline: + result = & GETSCDATA(Outline); + break; default: NS_ERROR("Invalid style struct id"); break; @@ -3141,9 +3437,6 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) case eStyleStruct_Color: result = & GETSCDATA(Color); break; - case eStyleStruct_Spacing: - result = & GETSCDATA(Spacing); - break; case eStyleStruct_List: result = & GETSCDATA(List); break; @@ -3168,6 +3461,18 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) case eStyleStruct_Print: result = & GETSCDATA(Print); break; + case eStyleStruct_Margin: + result = & GETSCDATA(Margin); + break; + case eStyleStruct_Padding: + result = & GETSCDATA(Padding); + break; + case eStyleStruct_Border: + result = & GETSCDATA(Border); + break; + case eStyleStruct_Outline: + result = & GETSCDATA(Outline); + break; default: NS_ERROR("Invalid style struct id"); break; @@ -3181,6 +3486,18 @@ nsStyleStruct* StyleContextImpl::GetMutableStyleData(nsStyleStructID aSID) return result; } +void StyleContextImpl::CalcBorderPaddingFor(const nsIFrame* aFrame, nsMargin& aBorderPadding) const +{ + nsMargin border, padding; + if (!GETSCDATA(Border).GetBorder(border)) { + GETSCDATA(Border).CalcBorderFor(aFrame, border); + } + if (!GETSCDATA(Padding).GetPadding(padding)) { + GETSCDATA(Padding).CalcPaddingFor(aFrame, padding); + } + aBorderPadding = border + padding; +} + NS_IMETHODIMP StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const { @@ -3192,9 +3509,6 @@ StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const case eStyleStruct_Color: GETSCDATA(Color).CopyTo((nsStyleColor&)aStruct); break; - case eStyleStruct_Spacing: - GETSCDATA(Spacing).CopyTo((nsStyleSpacing&)aStruct); - break; case eStyleStruct_List: GETSCDATA(List).CopyTo((nsStyleList&)aStruct); break; @@ -3219,6 +3533,27 @@ StyleContextImpl::GetStyle(nsStyleStructID aSID, nsStyleStruct& aStruct) const case eStyleStruct_Print: GETSCDATA(Print).CopyTo((nsStylePrint&)aStruct); break; + case eStyleStruct_Margin: + GETSCDATA(Margin).CopyTo((nsStyleMargin&)aStruct); + break; + case eStyleStruct_Padding: + GETSCDATA(Padding).CopyTo((nsStylePadding&)aStruct); + break; + case eStyleStruct_Border: + GETSCDATA(Border).CopyTo((nsStyleBorder&)aStruct); + break; + case eStyleStruct_Outline: + GETSCDATA(Outline).CopyTo((nsStyleOutline&)aStruct); + break; + case eStyleStruct_BorderPaddingShortcut: + nsMargin border, padding; + if (GETSCDATA(Border).GetBorder(border)) { + if (GETSCDATA(Padding).GetPadding(padding)) { + border += padding; + ((nsStyleBorderPadding&)aStruct).SetBorderPadding(border); + } + } + break; default: NS_ERROR("Invalid style struct id"); result = NS_ERROR_INVALID_ARG; @@ -3238,9 +3573,6 @@ StyleContextImpl::SetStyle(nsStyleStructID aSID, const nsStyleStruct& aStruct) case eStyleStruct_Color: GETSCDATA(Color).SetFrom((const nsStyleColor&)aStruct); break; - case eStyleStruct_Spacing: - GETSCDATA(Spacing).SetFrom((const nsStyleSpacing&)aStruct); - break; case eStyleStruct_List: GETSCDATA(List).SetFrom((const nsStyleList&)aStruct); break; @@ -3265,6 +3597,18 @@ StyleContextImpl::SetStyle(nsStyleStructID aSID, const nsStyleStruct& aStruct) case eStyleStruct_Print: GETSCDATA(Print).SetFrom((const nsStylePrint&)aStruct); break; + case eStyleStruct_Margin: + GETSCDATA(Margin).SetFrom((const nsStyleMargin&)aStruct); + break; + case eStyleStruct_Padding: + GETSCDATA(Padding).SetFrom((const nsStylePadding&)aStruct); + break; + case eStyleStruct_Border: + GETSCDATA(Border).SetFrom((const nsStyleBorder&)aStruct); + break; + case eStyleStruct_Outline: + GETSCDATA(Outline).SetFrom((const nsStyleOutline&)aStruct); + break; default: NS_ERROR("Invalid style struct id"); result = NS_ERROR_INVALID_ARG; @@ -3313,7 +3657,6 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) if (nsnull != mParent) { GETSCDATA(Font).ResetFrom(&(mParent->GETSCDATA(Font)), aPresContext); GETSCDATA(Color).ResetFrom(&(mParent->GETSCDATA(Color)), aPresContext); - GETSCDATA(Spacing).ResetFrom(&(mParent->GETSCDATA(Spacing)), aPresContext); GETSCDATA(List).ResetFrom(&(mParent->GETSCDATA(List)), aPresContext); GETSCDATA(Position).ResetFrom(&(mParent->GETSCDATA(Position)), aPresContext); GETSCDATA(Text).ResetFrom(&(mParent->GETSCDATA(Text)), aPresContext); @@ -3322,11 +3665,14 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(&(mParent->GETSCDATA(Content)), aPresContext); GETSCDATA(UserInterface).ResetFrom(&(mParent->GETSCDATA(UserInterface)), aPresContext); GETSCDATA(Print).ResetFrom(&(mParent->GETSCDATA(Print)), aPresContext); + GETSCDATA(Margin).ResetFrom(&(mParent->GETSCDATA(Margin)), aPresContext); + GETSCDATA(Padding).ResetFrom(&(mParent->GETSCDATA(Padding)), aPresContext); + GETSCDATA(Border).ResetFrom(&(mParent->GETSCDATA(Border)), aPresContext); + GETSCDATA(Outline).ResetFrom(&(mParent->GETSCDATA(Outline)), aPresContext); } else { GETSCDATA(Font).ResetFrom(nsnull, aPresContext); GETSCDATA(Color).ResetFrom(nsnull, aPresContext); - GETSCDATA(Spacing).ResetFrom(nsnull, aPresContext); GETSCDATA(List).ResetFrom(nsnull, aPresContext); GETSCDATA(Position).ResetFrom(nsnull, aPresContext); GETSCDATA(Text).ResetFrom(nsnull, aPresContext); @@ -3335,6 +3681,10 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(nsnull, aPresContext); GETSCDATA(UserInterface).ResetFrom(nsnull, aPresContext); GETSCDATA(Print).ResetFrom(nsnull, aPresContext); + GETSCDATA(Margin).ResetFrom(nsnull, aPresContext); + GETSCDATA(Padding).ResetFrom(nsnull, aPresContext); + GETSCDATA(Border).ResetFrom(nsnull, aPresContext); + GETSCDATA(Outline).ResetFrom(nsnull, aPresContext); } PRUint32 cnt = 0; @@ -3404,7 +3754,6 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Font).ResetFrom(nsnull, aPresContext); } GETSCDATA(Color).ResetFrom(nsnull, aPresContext); - GETSCDATA(Spacing).ResetFrom(nsnull, aPresContext); GETSCDATA(List).ResetFrom(nsnull, aPresContext); GETSCDATA(Text).ResetFrom(nsnull, aPresContext); GETSCDATA(Position).ResetFrom(nsnull, aPresContext); @@ -3413,6 +3762,10 @@ StyleContextImpl::RemapStyle(nsIPresContext* aPresContext, PRBool aRecurse) GETSCDATA(Content).ResetFrom(nsnull, aPresContext); GETSCDATA(UserInterface).ResetFrom(nsnull, aPresContext); GETSCDATA(Print).ResetFrom(nsnull, aPresContext); + GETSCDATA(Margin).ResetFrom(nsnull, aPresContext); + GETSCDATA(Padding).ResetFrom(nsnull, aPresContext); + GETSCDATA(Border).ResetFrom(nsnull, aPresContext); + GETSCDATA(Outline).ResetFrom(nsnull, aPresContext); GETSCDATA(Display).mVisible = visible; GETSCDATA(Display).mDirection = direction; GETSCDATA(Display).mLanguage = language; @@ -3497,7 +3850,10 @@ void StyleContextImpl::RecalcAutomaticData(nsIPresContext* aPresContext) if (NS_FAILED(EnsureStyleData(aPresContext))) { return /*NS_FAILURE*/; } - GETSCDATA(Spacing).RecalcData(aPresContext, GETSCDATA(Color).mColor); + GETSCDATA(Margin).RecalcData(); + GETSCDATA(Padding).RecalcData(); + GETSCDATA(Border).RecalcData(GETSCDATA(Color).mColor); + GETSCDATA(Outline).RecalcData(); } NS_IMETHODIMP @@ -3520,13 +3876,6 @@ StyleContextImpl::CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PR } } if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; - if (aHint < NS_STYLE_HINT_MAX) { - hint = GETSCDATA(Spacing).CalcDifference(other->GETSCDATA(Spacing)); - if (aHint < hint) { - aHint = hint; - } - } - if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; if (aHint < NS_STYLE_HINT_MAX) { hint = GETSCDATA(List).CalcDifference(other->GETSCDATA(List)); if (aHint < hint) { @@ -3582,6 +3931,34 @@ StyleContextImpl::CalcStyleDifference(nsIStyleContext* aOther, PRInt32& aHint,PR aHint = hint; } } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Margin).CalcDifference(other->GETSCDATA(Margin)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Padding).CalcDifference(other->GETSCDATA(Padding)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Border).CalcDifference(other->GETSCDATA(Border)); + if (aHint < hint) { + aHint = hint; + } + } + if (aStopAtFirstDifference && aHint > NS_STYLE_HINT_NONE) return NS_OK; + if (aHint < NS_STYLE_HINT_MAX) { + hint = GETSCDATA(Outline).CalcDifference(other->GETSCDATA(Outline)); + if (aHint < hint) { + aHint = hint; + } + } } return NS_OK; } @@ -3865,8 +4242,6 @@ void StyleContextImpl::SizeOf(nsISizeOfHandler *aSizeOfHandler, PRUint32 &aSize) totalSize += (long)sizeof(GETSCDATA(Font)); printf( " - StyleColorImpl: %ld\n", (long)sizeof(GETSCDATA(Color)) ); totalSize += (long)sizeof(GETSCDATA(Color)); - printf( " - StyleSpacingImpl: %ld\n", (long)sizeof(GETSCDATA(Spacing)) ); - totalSize += (long)sizeof(GETSCDATA(Spacing)); printf( " - StyleListImpl: %ld\n", (long)sizeof(GETSCDATA(List)) ); totalSize += (long)sizeof(GETSCDATA(List)); printf( " - StylePositionImpl: %ld\n", (long)sizeof(GETSCDATA(Position)) ); @@ -3883,6 +4258,14 @@ void StyleContextImpl::SizeOf(nsISizeOfHandler *aSizeOfHandler, PRUint32 &aSize) totalSize += (long)sizeof(GETSCDATA(UserInterface)); printf( " - StylePrintImpl: %ld\n", (long)sizeof(GETSCDATA(Print))); totalSize += (long)sizeof(GETSCDATA(Print)); + printf( " - StyleMarginImpl: %ld\n", (long)sizeof(GETSCDATA(Margin))); + totalSize += (long)sizeof(GETSCDATA(Margin)); + printf( " - StylePaddingImpl: %ld\n", (long)sizeof(GETSCDATA(Padding))); + totalSize += (long)sizeof(GETSCDATA(Padding)); + printf( " - StyleBorderImpl: %ld\n", (long)sizeof(GETSCDATA(Border))); + totalSize += (long)sizeof(GETSCDATA(Border)); + printf( " - StyleOutlineImpl: %ld\n", (long)sizeof(GETSCDATA(Outline))); + totalSize += (long)sizeof(GETSCDATA(Outline)); printf( " - Total: %ld\n", (long)totalSize); printf( "*************************************\n"); } @@ -3982,23 +4365,23 @@ void StyleContextImpl::DumpRegressionData(nsIPresContext* aPresContext, FILE* ou NS_ConvertUCS2toUTF8(GETSCDATA(Color).mCursorImage).get(), GETSCDATA(Color).mOpacity); - // SPACING + // SPACING (ie. margin, padding, border, outline) IndentBy(out,aIndent); fprintf(out, "\n"); // LIST diff --git a/mozilla/layout/tables/nsTableCellFrame.cpp b/mozilla/layout/tables/nsTableCellFrame.cpp index d8aed1f6884..9fa56143b9d 100644 --- a/mozilla/layout/tables/nsTableCellFrame.cpp +++ b/mozilla/layout/tables/nsTableCellFrame.cpp @@ -291,10 +291,10 @@ NS_METHOD nsTableCellFrame::Paint(nsIPresContext* aPresContext, } //END SELECTION - const nsStyleSpacing* mySpacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); NS_ASSERTION(nsnull!=myColor, "bad style color"); - NS_ASSERTION(nsnull!=mySpacing, "bad style spacing"); + NS_ASSERTION(nsnull!=myBorder, "bad style spacing"); const nsStyleTable* cellTableStyle; GetStyleData(eStyleStruct_Table, ((const nsStyleStruct *&)cellTableStyle)); @@ -303,7 +303,7 @@ NS_METHOD nsTableCellFrame::Paint(nsIPresContext* aPresContext, // only non empty cells render their background if (PR_FALSE == GetContentEmpty()) { nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *myColor, *mySpacing, 0, 0); + aDirtyRect, rect, *myColor, *myBorder, 0, 0); } // empty cells do not render their border @@ -325,7 +325,7 @@ NS_METHOD nsTableCellFrame::Paint(nsIPresContext* aPresContext, if (NS_STYLE_BORDER_SEPARATE == tableFrame->GetBorderCollapseStyle()) { nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mStyleContext, skipSides); + aDirtyRect, rect, *myBorder, mStyleContext, skipSides); } else { @@ -787,7 +787,7 @@ NS_METHOD nsTableCellFrame::Reflow(nsIPresContext* aPresContext, kidOrigin.MoveTo(leftInset, topInset); } else { // handle percent padding-left which was 0 during initial reflow - if (eStyleUnit_Percent == aReflowState.mStyleSpacing->mPadding.GetLeftUnit()) { + if (eStyleUnit_Percent == aReflowState.mStylePadding->mPadding.GetLeftUnit()) { nsRect kidRect; firstKid->GetRect(kidRect); // only move in the x direction for the same reason as above @@ -928,7 +928,7 @@ NS_METHOD nsTableCellFrame::Reflow(nsIPresContext* aPresContext, * */ void nsTableCellFrame::MapHTMLBorderStyle(nsIPresContext* aPresContext, - nsStyleSpacing& aSpacingStyle, + nsStyleBorder& aBorderStyle, nsTableFrame* aTableFrame) { //adjust the border style based on the table rules attribute @@ -942,20 +942,20 @@ void nsTableCellFrame::MapHTMLBorderStyle(nsIPresContext* aPresContext, switch (tableStyle->mRules) { case NS_STYLE_TABLE_RULES_NONE: - aSpacingStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_RULES_COLS: - aSpacingStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); break; case NS_STYLE_TABLE_RULES_ROWS: - aSpacingStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); - aSpacingStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_NONE); + aBorderStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_NONE); break; default: @@ -996,9 +996,9 @@ void nsTableCellFrame::MapBorderPadding(nsIPresContext* aPresContext) // get the table frame style context, and from it get cellpadding, cellspacing, and border info const nsStyleTable* tableStyle; tableFrame->GetStyleData(eStyleStruct_Table, (const nsStyleStruct *&)tableStyle); - const nsStyleSpacing* tableSpacingStyle; - tableFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct *&)tableSpacingStyle); - nsStyleSpacing* spacingData = (nsStyleSpacing*)mStyleContext->GetMutableStyleData(eStyleStruct_Spacing); + const nsStylePadding* tablePaddingStyle; + tableFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct *&)tablePaddingStyle); + nsStylePadding* paddingData = (nsStylePadding*)mStyleContext->GetMutableStyleData(eStyleStruct_Padding); float p2t; aPresContext->GetPixelsToTwips(&p2t); @@ -1011,16 +1011,17 @@ void nsTableCellFrame::MapBorderPadding(nsIPresContext* aPresContext) } // if the padding is not already set, set it to the table's cellpadding - if (eStyleUnit_Null == spacingData->mPadding.GetTopUnit()) - spacingData->mPadding.SetTop(defaultPadding); - if (eStyleUnit_Null == spacingData->mPadding.GetRightUnit()) - spacingData->mPadding.SetRight(defaultPadding); - if (eStyleUnit_Null == spacingData->mPadding.GetBottomUnit()) - spacingData->mPadding.SetBottom(defaultPadding); - if (eStyleUnit_Null == spacingData->mPadding.GetLeftUnit()) - spacingData->mPadding.SetLeft(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetTopUnit()) + paddingData->mPadding.SetTop(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetRightUnit()) + paddingData->mPadding.SetRight(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetBottomUnit()) + paddingData->mPadding.SetBottom(defaultPadding); + if (eStyleUnit_Null == paddingData->mPadding.GetLeftUnit()) + paddingData->mPadding.SetLeft(defaultPadding); - MapHTMLBorderStyle(aPresContext, *spacingData, tableFrame); + nsStyleBorder* borderData = (nsStyleBorder*)mStyleContext->GetMutableStyleData(eStyleStruct_Border); + MapHTMLBorderStyle(aPresContext, *borderData, tableFrame); MapVAlignAttribute(aPresContext, tableFrame); MapHAlignAttribute(aPresContext, tableFrame); @@ -1271,9 +1272,9 @@ nsTableCellFrame::GetCellBorder(nsMargin& aBorder, NS_PRECONDITION(mBorderEdges, "haven't allocated border edges struct"); aBorder = mBorderEdges->mMaxBorderWidth; } else { - const nsStyleSpacing* spacing; - GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - spacing->GetBorder(aBorder); + const nsStyleBorder* borderData; + GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)borderData); + borderData->GetBorder(aBorder); } } diff --git a/mozilla/layout/tables/nsTableCellFrame.h b/mozilla/layout/tables/nsTableCellFrame.h index 54062378e81..34cfaa32c77 100644 --- a/mozilla/layout/tables/nsTableCellFrame.h +++ b/mozilla/layout/tables/nsTableCellFrame.h @@ -28,7 +28,6 @@ #include "nsTableRowFrame.h" // need to actually include this here to inline GetRowIndex #include "nsIStyleContext.h" -struct nsStyleSpacing; class nsTableFrame; class nsHTMLValue; @@ -257,7 +256,7 @@ protected: void MapBorderPadding(nsIPresContext* aPresContext); void MapHTMLBorderStyle(nsIPresContext* aPresContext, - nsStyleSpacing& aSpacingStyle, + nsStyleBorder& aBorderStyle, nsTableFrame* aTableFrame); void MapVAlignAttribute(nsIPresContext* aPresContext, nsTableFrame *aTableFrame); diff --git a/mozilla/layout/tables/nsTableColFrame.cpp b/mozilla/layout/tables/nsTableColFrame.cpp index 2b0905e7698..81be1b7f76d 100644 --- a/mozilla/layout/tables/nsTableColFrame.cpp +++ b/mozilla/layout/tables/nsTableColFrame.cpp @@ -115,13 +115,13 @@ NS_METHOD nsTableColFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/tables/nsTableColGroupFrame.cpp b/mozilla/layout/tables/nsTableColGroupFrame.cpp index 2d4e048e81d..fa4fd76c5ec 100644 --- a/mozilla/layout/tables/nsTableColGroupFrame.cpp +++ b/mozilla/layout/tables/nsTableColGroupFrame.cpp @@ -441,13 +441,13 @@ NS_METHOD nsTableColGroupFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/tables/nsTableFrame.cpp b/mozilla/layout/tables/nsTableFrame.cpp index 17b1b821487..0534a6ac401 100644 --- a/mozilla/layout/tables/nsTableFrame.cpp +++ b/mozilla/layout/tables/nsTableFrame.cpp @@ -575,16 +575,16 @@ void nsTableFrame::ProcessGroupRules(nsIPresContext* aPresContext) if (originates) { nsCOMPtr styleContext; cell->GetStyleContext(getter_AddRefs(styleContext)); - nsStyleSpacing* spacing = (nsStyleSpacing*)styleContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* border = (nsStyleBorder*)styleContext->GetMutableStyleData(eStyleStruct_Border); if (rowX == startRow) { - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); } else if (rowX == endRow) { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); } else { - spacing->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); - spacing->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_NONE); + border->SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_NONE); } styleContext->RecalcAutomaticData(aPresContext); } @@ -1330,8 +1330,8 @@ NS_METHOD nsTableFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); @@ -1341,7 +1341,7 @@ NS_METHOD nsTableFrame::Paint(nsIPresContext* aPresContext, aPresContext->GetCompatibilityMode(&mode); if (eCompatibility_NavQuirks != mode) { nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } // paint the column groups and columns nsIFrame* colGroupFrame = mColGroups.FirstChild(); @@ -1354,7 +1354,7 @@ NS_METHOD nsTableFrame::Paint(nsIPresContext* aPresContext, if (NS_STYLE_BORDER_SEPARATE == GetBorderCollapseStyle()) { nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *border, mStyleContext, skipSides); } else { @@ -1515,8 +1515,6 @@ nsresult nsTableFrame::AdjustSiblingsAfterReflow(nsIPresContext* aPresCon // Update the max element size //XXX: this should call into layout strategy to get the width field if (aMaxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -1865,10 +1863,10 @@ NS_METHOD nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresContext, // Get the table's border padding nsMargin borderPadding; GetTableBorderForRowGroup(GetRowGroupFrame(kidFrame), borderPadding); - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)tableSpacing)); + const nsStylePadding* tablePadding; + GetStyleData(eStyleStruct_Padding, ((const nsStyleStruct *&)tablePadding)); nsMargin padding; - tableSpacing->GetPadding(padding); + tablePadding->GetPadding(padding); borderPadding += padding; y += cellSpacingY; @@ -1923,12 +1921,12 @@ NS_METHOD nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresContext, } // Get the table's border/padding - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStylePadding* myPadding = (const nsStylePadding*) + mStyleContext->GetStyleData(eStyleStruct_Padding); nsMargin tableBorderPadding; GetTableBorder (tableBorderPadding); // this gets the max border thickness at each edge nsMargin tablePadding; - mySpacing->GetPadding(tablePadding); + myPadding->GetPadding(tablePadding); tableBorderPadding += tablePadding; aDesiredSize.width = kidSize.width; @@ -2790,8 +2788,6 @@ nsTableFrame::RecoverState(InnerTableReflowState& aReflowState, //XXX: this should call into layout strategy to get the width field if (nsnull != aMaxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -2852,8 +2848,6 @@ NS_METHOD nsTableFrame::IR_TargetIsChild(nsIPresContext* aPresContext, //XXX: this should call into layout strategy to get the width field if (nsnull != aDesiredSize.maxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -2972,8 +2966,6 @@ void nsTableFrame::PlaceChild(nsIPresContext* aPresContext, //XXX: this should call into layout strategy to get the width field if (nsnull != aMaxElementSize) { - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing , ((const nsStyleStruct *&)tableSpacing)); nsMargin borderPadding; GetTableBorder (borderPadding); // gets the max border thickness for each edge borderPadding += aReflowState.reflowState.mComputedPadding; @@ -3106,8 +3098,6 @@ NS_METHOD nsTableFrame::ReflowMappedChildren(nsIPresContext* aPresContext nsMargin borderPadding; GetTableBorderForRowGroup(GetRowGroupFrame(kidFrame), borderPadding); - const nsStyleSpacing* tableSpacing; - GetStyleData(eStyleStruct_Spacing, ((const nsStyleStruct *&)tableSpacing)); borderPadding += aReflowState.reflowState.mComputedPadding; // Reflow the child into the available space @@ -3789,19 +3779,19 @@ void nsTableFrame::SetColumnWidth(PRInt32 aColIndex, nscoord aWidth) * Update the border style to map to the HTML border style * */ -void nsTableFrame::MapHTMLBorderStyle(nsStyleSpacing& aSpacingStyle, nscoord aBorderWidth) +void nsTableFrame::MapHTMLBorderStyle(nsStyleBorder& aBorderStyle, nscoord aBorderWidth) { nsStyleCoord width; width.SetCoordValue(aBorderWidth); - aSpacingStyle.mBorder.SetTop(width); - aSpacingStyle.mBorder.SetLeft(width); - aSpacingStyle.mBorder.SetBottom(width); - aSpacingStyle.mBorder.SetRight(width); + aBorderStyle.mBorder.SetTop(width); + aBorderStyle.mBorder.SetLeft(width); + aBorderStyle.mBorder.SetBottom(width); + aBorderStyle.mBorder.SetRight(width); - aSpacingStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_BG_OUTSET); - aSpacingStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_BG_OUTSET); - aSpacingStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_BG_OUTSET); - aSpacingStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_TOP, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_LEFT, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_BOTTOM, NS_STYLE_BORDER_STYLE_BG_OUTSET); + aBorderStyle.SetBorderStyle(NS_SIDE_RIGHT, NS_STYLE_BORDER_STYLE_BG_OUTSET); nsIStyleContext* styleContext = mStyleContext; const nsStyleColor* colorData = (const nsStyleColor*) @@ -3839,10 +3829,10 @@ void nsTableFrame::MapHTMLBorderStyle(nsStyleSpacing& aSpacingStyle, nscoord aBo if (borderColor == 0xFFFFFFFF) borderColor = 0xFFC0C0C0; - aSpacingStyle.SetBorderColor(NS_SIDE_TOP, borderColor); - aSpacingStyle.SetBorderColor(NS_SIDE_LEFT, borderColor); - aSpacingStyle.SetBorderColor(NS_SIDE_BOTTOM, borderColor); - aSpacingStyle.SetBorderColor(NS_SIDE_RIGHT, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_TOP, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_LEFT, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_BOTTOM, borderColor); + aBorderStyle.SetBorderColor(NS_SIDE_RIGHT, borderColor); } @@ -3890,7 +3880,7 @@ void nsTableFrame::MapBorderMarginPadding(nsIPresContext* aPresContext) if (!table) return; - nsStyleSpacing* spacingData = (nsStyleSpacing*)mStyleContext->GetMutableStyleData(eStyleStruct_Spacing); + nsStyleBorder* borderData = (nsStyleBorder*)mStyleContext->GetMutableStyleData(eStyleStruct_Border); border_result = table->GetAttribute(nsHTMLAtoms::border,border_value); if (border_result == NS_CONTENT_ATTR_HAS_VALUE) @@ -3900,7 +3890,7 @@ void nsTableFrame::MapBorderMarginPadding(nsIPresContext* aPresContext) if (ConvertToPixelValue(border_value,1,intValue)) //XXX this is busted if this code is ever used again. MMP border = NSIntPixelsToTwips(intValue, p2t); } - MapHTMLBorderStyle(*spacingData,border); + MapHTMLBorderStyle(*borderData,border); #endif } @@ -3915,39 +3905,39 @@ CalcPercentPadding(nscoord aBasis, void GetPaddingFor(const nsSize& aBasis, - const nsStyleSpacing& aSpacing, + const nsStylePadding& aPaddingData, nsMargin& aPadding) { nsStyleCoord styleCoord; - aSpacing.mPadding.GetTop(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetTopUnit()) { + aPaddingData.mPadding.GetTop(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetTopUnit()) { aPadding.top = CalcPercentPadding(aBasis.height, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.top = styleCoord.GetCoordValue(); } - aSpacing.mPadding.GetRight(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetRightUnit()) { + aPaddingData.mPadding.GetRight(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetRightUnit()) { aPadding.right = CalcPercentPadding(aBasis.width, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.right = styleCoord.GetCoordValue(); } - aSpacing.mPadding.GetBottom(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetBottomUnit()) { + aPaddingData.mPadding.GetBottom(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetBottomUnit()) { aPadding.bottom = CalcPercentPadding(aBasis.height, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.bottom = styleCoord.GetCoordValue(); } - aSpacing.mPadding.GetLeft(styleCoord); - if (eStyleUnit_Percent == aSpacing.mPadding.GetLeftUnit()) { + aPaddingData.mPadding.GetLeft(styleCoord); + if (eStyleUnit_Percent == aPaddingData.mPadding.GetLeftUnit()) { aPadding.left = CalcPercentPadding(aBasis.width, styleCoord); } - else if (eStyleUnit_Coord == aSpacing.mPadding.GetTopUnit()) { + else if (eStyleUnit_Coord == aPaddingData.mPadding.GetTopUnit()) { aPadding.left = styleCoord.GetCoordValue(); } } @@ -3956,10 +3946,10 @@ nsMargin nsTableFrame::GetPadding(const nsHTMLReflowState& aReflowState, const nsTableCellFrame* aCellFrame) { - const nsStyleSpacing* spacing; - aCellFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct *&)spacing); + const nsStylePadding* paddingData; + aCellFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct *&)paddingData); nsMargin padding(0,0,0,0); - if (!spacing->GetPadding(padding)) { + if (!paddingData->GetPadding(padding)) { const nsHTMLReflowState* parentRS = aReflowState.parentReflowState; while (parentRS) { if (parentRS->frame) { @@ -3967,7 +3957,7 @@ nsTableFrame::GetPadding(const nsHTMLReflowState& aReflowState, parentRS->frame->GetFrameType(getter_AddRefs(frameType)); if (nsLayoutAtoms::tableFrame == frameType.get()) { nsSize basis(parentRS->mComputedWidth, parentRS->mComputedHeight); - GetPaddingFor(basis, *spacing, padding); + GetPaddingFor(basis, *paddingData, padding); break; } } @@ -3981,11 +3971,11 @@ nsMargin nsTableFrame::GetPadding(const nsSize& aBasis, const nsTableCellFrame* aCellFrame) { - const nsStyleSpacing* spacing; - aCellFrame->GetStyleData(eStyleStruct_Spacing,(const nsStyleStruct *&)spacing); + const nsStylePadding* paddingData; + aCellFrame->GetStyleData(eStyleStruct_Padding,(const nsStyleStruct *&)paddingData); nsMargin padding(0,0,0,0); - if (!spacing->GetPadding(padding)) { - GetPaddingFor(aBasis, *spacing, padding); + if (!paddingData->GetPadding(padding)) { + GetPaddingFor(aBasis, *paddingData, padding); } return padding; } @@ -3997,9 +3987,9 @@ void nsTableFrame::GetTableBorder(nsMargin &aBorder) mBorderCollapser->GetBorder(aBorder); } else { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); - spacing->GetBorder(aBorder); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); + border->GetBorder(aBorder); } } @@ -4019,9 +4009,9 @@ void nsTableFrame::GetTableBorderAt(PRInt32 aRowIndex, } } else { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); - spacing->GetBorder(aBorder); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); + border->GetBorder(aBorder); } } @@ -4211,13 +4201,16 @@ nscoord nsTableFrame::CalcBorderBoxWidth(const nsHTMLReflowState& aState) } if (NS_UNCONSTRAINEDSIZE != aState.availableWidth) { nsMargin margin(0,0,0,0); - aState.mStyleSpacing->GetMargin(margin); + aState.mStyleMargin->GetMargin(margin); width = aState.availableWidth - margin.left - margin.right; } } else if (width != NS_UNCONSTRAINEDSIZE) { + nsMargin border(0,0,0,0); + aState.mStyleBorder->GetBorder(border); nsMargin borderPadding(0,0,0,0); - aState.mStyleSpacing->GetBorderPadding(borderPadding); + aState.mStylePadding->GetPadding(borderPadding); + borderPadding += border; width += borderPadding.left + borderPadding.right; } width = PR_MAX(width, 0); diff --git a/mozilla/layout/tables/nsTableFrame.h b/mozilla/layout/tables/nsTableFrame.h index 1474fbc22c3..0a083ddda1d 100644 --- a/mozilla/layout/tables/nsTableFrame.h +++ b/mozilla/layout/tables/nsTableFrame.h @@ -44,7 +44,6 @@ class nsHTMLValue; struct InnerTableReflowState; struct nsStylePosition; -struct nsStyleSpacing; /** * Child list name indices @@ -708,7 +707,7 @@ protected: /** Support methods for DidSetStyleContext */ void MapBorderMarginPadding(nsIPresContext* aPresContext); - void MapHTMLBorderStyle(nsStyleSpacing& aSpacingStyle, nscoord aBorderWidth); + void MapHTMLBorderStyle(nsStyleBorder& aBorderStyle, nscoord aBorderWidth); PRBool ConvertToPixelValue(nsHTMLValue& aValue, PRInt32 aDefault, PRInt32& aResult); public: diff --git a/mozilla/layout/tables/nsTableOuterFrame.cpp b/mozilla/layout/tables/nsTableOuterFrame.cpp index 60593a093b5..b2ce6dedb72 100644 --- a/mozilla/layout/tables/nsTableOuterFrame.cpp +++ b/mozilla/layout/tables/nsTableOuterFrame.cpp @@ -432,10 +432,10 @@ void nsTableOuterFrame::ZeroAutoMargin(nsHTMLReflowState& aReflowState, nsMargin& aMargin) { - if (eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetLeftUnit()) { + if (eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetLeftUnit()) { aMargin.left = 0; } - if (eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetRightUnit()) { + if (eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetRightUnit()) { aMargin.right = 0; } } @@ -445,8 +445,8 @@ FixAutoMargins(nscoord aAvailWidth, nsHTMLReflowState& aReflowState) { // see if there are auto margins. they may have been set to 0 in mComputedMargin - PRBool hasAutoMargin = eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetLeftUnit() || - eStyleUnit_Auto == aReflowState.mStyleSpacing->mMargin.GetRightUnit(); + PRBool hasAutoMargin = eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetLeftUnit() || + eStyleUnit_Auto == aReflowState.mStyleMargin->mMargin.GetRightUnit(); if (hasAutoMargin) { nsRect rect; aReflowState.frame->GetRect(rect); diff --git a/mozilla/layout/tables/nsTableRowFrame.cpp b/mozilla/layout/tables/nsTableRowFrame.cpp index e2d6aa45201..5cfb70a0490 100644 --- a/mozilla/layout/tables/nsTableRowFrame.cpp +++ b/mozilla/layout/tables/nsTableRowFrame.cpp @@ -511,8 +511,8 @@ NS_METHOD nsTableRowFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsTableFrame* tableFrame = nsnull; @@ -525,7 +525,7 @@ NS_METHOD nsTableRowFrame::Paint(nsIPresContext* aPresContext, nsRect rect(0, 0, mRect.width + cellSpacingX, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/tables/nsTableRowGroupFrame.cpp b/mozilla/layout/tables/nsTableRowGroupFrame.cpp index 81796fadfd4..ee035cc2aaf 100644 --- a/mozilla/layout/tables/nsTableRowGroupFrame.cpp +++ b/mozilla/layout/tables/nsTableRowGroupFrame.cpp @@ -199,8 +199,8 @@ NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext* aPresContext, const nsStyleDisplay* disp = (const nsStyleDisplay*)mStyleContext->GetStyleData(eStyleStruct_Display); if (disp->IsVisibleOrCollapsed()) { - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); nsTableFrame* tableFrame = nsnull; @@ -210,7 +210,7 @@ NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext* aPresContext, } nsRect rect(0,0,mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); } } } diff --git a/mozilla/layout/xul/base/src/nsBox.cpp b/mozilla/layout/xul/base/src/nsBox.cpp index ded8d4d629b..93a702917cc 100644 --- a/mozilla/layout/xul/base/src/nsBox.cpp +++ b/mozilla/layout/xul/base/src/nsBox.cpp @@ -598,20 +598,16 @@ nsBox::GetLayoutFlags(PRUint32& aFlags) NS_IMETHODIMP nsBox::GetBorderAndPadding(nsMargin& aBorderAndPadding) { - nsIFrame* frame = nsnull; - GetFrame(&frame); - - const nsStyleSpacing* spacing; - nsresult rv = frame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - + nsMargin border; + nsresult rv = GetBorder(border); if (NS_FAILED(rv)) return rv; - nsMargin border; nsMargin padding; - GetBorder(border); - GetPadding(padding); + rv = GetPadding(padding); + if (NS_FAILED(rv)) + return rv; + aBorderAndPadding.SizeTo(0,0,0,0); aBorderAndPadding += border; aBorderAndPadding += padding; @@ -625,15 +621,15 @@ nsBox::GetBorder(nsMargin& aMargin) nsIFrame* frame = nsnull; GetFrame(&frame); - const nsStyleSpacing* spacing; - nsresult rv = frame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); + const nsStyleBorder* border; + nsresult rv = frame->GetStyleData(eStyleStruct_Border, + (const nsStyleStruct*&) border); if (NS_FAILED(rv)) return rv; aMargin.SizeTo(0,0,0,0); - spacing->GetBorder(aMargin); + border->GetBorder(aMargin); return rv; } @@ -644,15 +640,15 @@ nsBox::GetPadding(nsMargin& aMargin) nsIFrame* frame = nsnull; GetFrame(&frame); - const nsStyleSpacing* spacing; - nsresult rv = frame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); + const nsStylePadding* padding; + nsresult rv = frame->GetStyleData(eStyleStruct_Padding, + (const nsStyleStruct*&) padding); if (NS_FAILED(rv)) return rv; aMargin.SizeTo(0,0,0,0); - spacing->GetPadding(aMargin); + padding->GetPadding(aMargin); return rv; } @@ -663,15 +659,15 @@ nsBox::GetMargin(nsMargin& aMargin) nsIFrame* frame = nsnull; GetFrame(&frame); - const nsStyleSpacing* spacing; - nsresult rv = frame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); + const nsStyleMargin* margin; + nsresult rv = frame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) margin); if (NS_FAILED(rv)) return rv; aMargin.SizeTo(0,0,0,0); - spacing->GetMargin(aMargin); + margin->GetMargin(aMargin); return rv; } @@ -1102,10 +1098,10 @@ nsBox::Redraw(nsBoxLayoutState& aState, // Checks to see if the damaged rect should be infalted // to include the outline - const nsStyleSpacing* spacing; - frame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); + const nsStyleOutline* outline; + frame->GetStyleData(eStyleStruct_Outline, (const nsStyleStruct*&)outline); nscoord width; - spacing->GetOutlineWidth(width); + outline->GetOutlineWidth(width); if (width > 0) { damageRect.Inflate(width, width); } diff --git a/mozilla/layout/xul/base/src/nsBoxFrame.cpp b/mozilla/layout/xul/base/src/nsBoxFrame.cpp index 530a19a7115..0753e870fb2 100644 --- a/mozilla/layout/xul/base/src/nsBoxFrame.cpp +++ b/mozilla/layout/xul/base/src/nsBoxFrame.cpp @@ -1295,16 +1295,18 @@ nsBoxFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); + const nsStyleOutline* outline = (const nsStyleOutline*) + mStyleContext->GetStyleData(eStyleStruct_Outline); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *border, mStyleContext, skipSides); nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, *outline, mStyleContext, 0); // The sole purpose of this is to trigger display // of the selection window for Named Anchors, diff --git a/mozilla/layout/xul/base/src/nsBoxObject.cpp b/mozilla/layout/xul/base/src/nsBoxObject.cpp index 814fcd13b81..d0f7bec9a3f 100644 --- a/mozilla/layout/xul/base/src/nsBoxObject.cpp +++ b/mozilla/layout/xul/base/src/nsBoxObject.cpp @@ -185,28 +185,28 @@ nsBoxObject::GetOffsetRect(nsRect& aRect) } // For the origin, add in the border for the frame - const nsStyleSpacing* spacing; + const nsStyleBorder* border; nsStyleCoord coord; - frame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)spacing); - if (spacing) { - if (eStyleUnit_Coord == spacing->mBorder.GetLeftUnit()) { - origin.x += spacing->mBorder.GetLeft(coord).GetCoordValue(); + frame->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)border); + if (border) { + if (eStyleUnit_Coord == border->mBorder.GetLeftUnit()) { + origin.x += border->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == spacing->mBorder.GetTopUnit()) { - origin.y += spacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == border->mBorder.GetTopUnit()) { + origin.y += border->mBorder.GetTop(coord).GetCoordValue(); } } // And subtract out the border for the parent if (parent) { - const nsStyleSpacing* parentSpacing; - parent->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct*&)parentSpacing); - if (parentSpacing) { - if (eStyleUnit_Coord == parentSpacing->mBorder.GetLeftUnit()) { - origin.x -= parentSpacing->mBorder.GetLeft(coord).GetCoordValue(); + const nsStyleBorder* parentBorder; + parent->GetStyleData(eStyleStruct_Border, (const nsStyleStruct*&)parentBorder); + if (parentBorder) { + if (eStyleUnit_Coord == parentBorder->mBorder.GetLeftUnit()) { + origin.x -= parentBorder->mBorder.GetLeft(coord).GetCoordValue(); } - if (eStyleUnit_Coord == parentSpacing->mBorder.GetTopUnit()) { - origin.y -= parentSpacing->mBorder.GetTop(coord).GetCoordValue(); + if (eStyleUnit_Coord == parentBorder->mBorder.GetTopUnit()) { + origin.y -= parentBorder->mBorder.GetTop(coord).GetCoordValue(); } } } diff --git a/mozilla/layout/xul/base/src/nsDeckFrame.cpp b/mozilla/layout/xul/base/src/nsDeckFrame.cpp index 5f7a947de0f..9daffcc925e 100644 --- a/mozilla/layout/xul/base/src/nsDeckFrame.cpp +++ b/mozilla/layout/xul/base/src/nsDeckFrame.cpp @@ -309,14 +309,14 @@ nsDeckFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *border, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *border, mStyleContext, skipSides); } } diff --git a/mozilla/layout/xul/base/src/nsGroupBoxFrame.cpp b/mozilla/layout/xul/base/src/nsGroupBoxFrame.cpp index 58f3c0501ab..e583e23a796 100644 --- a/mozilla/layout/xul/base/src/nsGroupBoxFrame.cpp +++ b/mozilla/layout/xul/base/src/nsGroupBoxFrame.cpp @@ -112,11 +112,11 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* borderStyleData = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); nsMargin border; - if (!spacing->GetBorder(border)) { + if (!borderStyleData->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } @@ -131,12 +131,12 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, // if the border is smaller than the legend. Move the border down // to be centered on the legend. - const nsStyleSpacing* titleSpacing; - titleFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) titleSpacing); + const nsStyleMargin* titleMarginData; + titleFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) titleMarginData); nsMargin titleMargin; - titleSpacing->GetMargin(titleMargin); + titleMarginData->GetMargin(titleMargin); titleRect.Inflate(titleMargin); if (border.top < titleRect.height) @@ -146,7 +146,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, nsRect rect(0, yoff, mRect.width, mRect.height - yoff); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *borderStyleData, 0, 0); if (titleBox) { @@ -163,7 +163,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyleData, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -177,7 +177,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyleData, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -192,7 +192,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyleData, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -200,7 +200,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *spacing, mStyleContext, skipSides); + aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *borderStyleData, mStyleContext, skipSides); } } } diff --git a/mozilla/layout/xul/base/src/nsScrollBoxFrame.cpp b/mozilla/layout/xul/base/src/nsScrollBoxFrame.cpp index ce6ccc28582..e4cb8ca510d 100644 --- a/mozilla/layout/xul/base/src/nsScrollBoxFrame.cpp +++ b/mozilla/layout/xul/base/src/nsScrollBoxFrame.cpp @@ -250,8 +250,8 @@ nsScrollBoxFrame::CreateScrollingView(nsIPresContext* aPresContext) mStyleContext->GetStyleData(eStyleStruct_Position); const nsStyleColor* color = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* borderStyle = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); const nsStyleDisplay* display = (const nsStyleDisplay*) mStyleContext->GetStyleData(eStyleStruct_Display); @@ -292,7 +292,7 @@ nsScrollBoxFrame::CreateScrollingView(nsIPresContext* aPresContext) // Set the scrolling view's insets to whatever our border is nsMargin border; - if (!spacing->GetBorder(border)) { + if (!borderStyle->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); border.SizeTo(0, 0, 0, 0); } @@ -593,12 +593,12 @@ nsScrollBoxFrame::Paint(nsIPresContext* aPresContext, if (display->IsVisibleOrCollapsed()) { // Paint our border only (no background) - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* border = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, 0); + aDirtyRect, rect, *border, mStyleContext, 0); } } diff --git a/mozilla/layout/xul/base/src/nsSliderFrame.cpp b/mozilla/layout/xul/base/src/nsSliderFrame.cpp index 7a43cf74dc4..69d19565665 100644 --- a/mozilla/layout/xul/base/src/nsSliderFrame.cpp +++ b/mozilla/layout/xul/base/src/nsSliderFrame.cpp @@ -296,13 +296,13 @@ nsSliderFrame::Paint(nsIPresContext* aPresContext, if (disp->IsVisibleOrCollapsed()) { const nsStyleColor* myColor = (const nsStyleColor*) mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* mySpacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* myBorder = (const nsStyleBorder*) + mStyleContext->GetStyleData(eStyleStruct_Border); nsRect rect(0, 0, mRect.width, mRect.height); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *myColor, *mySpacing, 0, 0); + aDirtyRect, rect, *myColor, *myBorder, 0, 0); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *mySpacing, mStyleContext, 0); + aDirtyRect, rect, *myBorder, mStyleContext, 0); } } return NS_OK; @@ -691,15 +691,6 @@ nsSliderFrame::CurrentPositionChanged(nsIPresContext* aPresContext) nsRect thumbRect; thumbFrame->GetRect(thumbRect); - // get our border and padding - const nsStyleSpacing* spacing; - nsresult rv = GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) spacing); - - NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get spacing"); - if (NS_FAILED(rv)) - return rv; - nsRect clientRect; GetClientRect(clientRect); diff --git a/mozilla/layout/xul/base/src/nsStackFrame.cpp b/mozilla/layout/xul/base/src/nsStackFrame.cpp index b0e9e3839e0..0f9fc511160 100644 --- a/mozilla/layout/xul/base/src/nsStackFrame.cpp +++ b/mozilla/layout/xul/base/src/nsStackFrame.cpp @@ -94,9 +94,9 @@ nsStackFrame::GetFrameForPoint(nsIPresContext* aPresContext, nsMargin im(0,0,0,0); GetInset(im); nsMargin border(0,0,0,0); - const nsStyleSpacing* spacing = (const nsStyleSpacing*) - mStyleContext->GetStyleData(eStyleStruct_Spacing); - spacing->GetBorderPadding(border); + nsStyleBorderPadding bPad; + aFrame->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + bPad.GetBorderPadding(borderPadding); r.Deflate(im); r.Deflate(border); diff --git a/mozilla/layout/xul/base/src/nsTextBoxFrame.cpp b/mozilla/layout/xul/base/src/nsTextBoxFrame.cpp index c0daa16f613..be7a7313d47 100644 --- a/mozilla/layout/xul/base/src/nsTextBoxFrame.cpp +++ b/mozilla/layout/xul/base/src/nsTextBoxFrame.cpp @@ -210,9 +210,10 @@ nsTextBoxFrame::Paint(nsIPresContext* aPresContext, if (NS_FRAME_PAINT_LAYER_FOREGROUND == aWhichLayer) { // remove the border and padding - const nsStyleSpacing* spacing = (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + nsStyleBorderPadding bPad; + mStyleContext->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); nsMargin border(0,0,0,0); - spacing->GetBorderPadding(border); + bPad.GetBorderPadding(border); nsRect textRect(0,0,mRect.width, mRect.height); textRect.Deflate(border); diff --git a/mozilla/layout/xul/base/src/nsTitledBoxFrame.cpp b/mozilla/layout/xul/base/src/nsTitledBoxFrame.cpp index 58f3c0501ab..e583e23a796 100644 --- a/mozilla/layout/xul/base/src/nsTitledBoxFrame.cpp +++ b/mozilla/layout/xul/base/src/nsTitledBoxFrame.cpp @@ -112,11 +112,11 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, PRIntn skipSides = GetSkipSides(); const nsStyleColor* color = (const nsStyleColor*)mStyleContext->GetStyleData(eStyleStruct_Color); - const nsStyleSpacing* spacing = - (const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing); + const nsStyleBorder* borderStyleData = + (const nsStyleBorder*)mStyleContext->GetStyleData(eStyleStruct_Border); nsMargin border; - if (!spacing->GetBorder(border)) { + if (!borderStyleData->GetBorder(border)) { NS_NOTYETIMPLEMENTED("percentage border"); } @@ -131,12 +131,12 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, // if the border is smaller than the legend. Move the border down // to be centered on the legend. - const nsStyleSpacing* titleSpacing; - titleFrame->GetStyleData(eStyleStruct_Spacing, - (const nsStyleStruct*&) titleSpacing); + const nsStyleMargin* titleMarginData; + titleFrame->GetStyleData(eStyleStruct_Margin, + (const nsStyleStruct*&) titleMarginData); nsMargin titleMargin; - titleSpacing->GetMargin(titleMargin); + titleMarginData->GetMargin(titleMargin); titleRect.Inflate(titleMargin); if (border.top < titleRect.height) @@ -146,7 +146,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, nsRect rect(0, yoff, mRect.width, mRect.height - yoff); nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *color, *spacing, 0, 0); + aDirtyRect, rect, *color, *borderStyleData, 0, 0); if (titleBox) { @@ -163,7 +163,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyleData, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -177,7 +177,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyleData, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -192,7 +192,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, aRenderingContext.PushState(); aRenderingContext.SetClipRect(clipRect, nsClipCombine_kIntersect, clipState); nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, rect, *spacing, mStyleContext, skipSides); + aDirtyRect, rect, *borderStyleData, mStyleContext, skipSides); aRenderingContext.PopState(clipState); @@ -200,7 +200,7 @@ nsTitledBoxFrame::Paint(nsIPresContext* aPresContext, nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this, - aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *spacing, mStyleContext, skipSides); + aDirtyRect, nsRect(0,0,mRect.width, mRect.height), *borderStyleData, mStyleContext, skipSides); } } } diff --git a/mozilla/layout/xul/base/src/nsXULTreeOuterGroupFrame.cpp b/mozilla/layout/xul/base/src/nsXULTreeOuterGroupFrame.cpp index 1a49337345a..f45e1d5ead2 100644 --- a/mozilla/layout/xul/base/src/nsXULTreeOuterGroupFrame.cpp +++ b/mozilla/layout/xul/base/src/nsXULTreeOuterGroupFrame.cpp @@ -1756,13 +1756,16 @@ nsXULTreeOuterGroupFrame::ComputeIntrinsicWidth(nsBoxLayoutState& aBoxLayoutStat aBoxLayoutState.GetPresContext()->ResolveStyleContextFor(firstRowContent, nsnull, PR_FALSE, getter_AddRefs(styleContext)); - const nsStyleSpacing* spacing = (const nsStyleSpacing*)styleContext->GetStyleData(eStyleStruct_Spacing); nscoord width = 0; nsMargin margin; - spacing->GetBorderPadding(margin); + nsStyleBorderPadding bPad; + styleContext->GetStyle(eStyleStruct_BorderPaddingShortcut, (nsStyleStruct&)bPad); + bPad.GetBorderPadding(margin); width += (margin.left + margin.right); - spacing->GetMargin(margin); + + const nsStyleMargin* styleMargin = (const nsStyleMargin*)styleContext->GetStyleData(eStyleStruct_Margin); + styleMargin->GetMargin(margin); width += (margin.left + margin.right); nsCOMPtr content;