wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Use logical text layout API for GetSkipSides. Bug 789096, r=jfkthame

Browse Source
This commit is contained in:
Simon Montagu 2014-03-10 22:19:03 -07:00
parent 8db501aece
commit 02482367cf
23 changed files with 167 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
layout/base/nsBidiPresUtils.cpp
View File

@ -1385,24 +1385,20 @@ nsBidiPresUtils::RepositionFrame(nsIFrame* aFrame,
WritingMode frameWM = aFrame->GetWritingMode();
nsInlineFrame* testFrame = do_QueryFrame(aFrame);
//XXX temporary until GetSkipSides is logicalized
bool isLeftMost = false, isRightMost = false;
if (testFrame) {
aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET);
isLeftMost = ((isFirst && frameWM.IsBidiLTR()) ||
(isLast && !frameWM.IsBidiLTR()));
if (isLeftMost)
aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LEFT_MOST);
else
aFrame->RemoveStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LEFT_MOST);
if (isFirst) {
aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST);
} else {
aFrame->RemoveStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST);
}
isRightMost = ((isLast && frameWM.IsBidiLTR()) ||
(isFirst && !frameWM.IsBidiLTR()));
if (isRightMost)
aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_RIGHT_MOST);
else
aFrame->RemoveStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_RIGHT_MOST);
if (isLast) {
aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST);
} else {
aFrame->RemoveStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST);
}
}
// This method is called from nsBlockFrame::PlaceLine via the call to
// bidiUtils->ReorderFrames, so this is guaranteed to be after the inlines

16
layout/generic/nsBlockFrame.cpp
View File

@ -968,19 +968,21 @@ nsBlockFrame::Reflow(nsPresContext* aPresContext,
if (aReflowState.AvailableHeight() != NS_UNCONSTRAINEDSIZE &&
aReflowState.ComputedHeight() != NS_AUTOHEIGHT &&
ShouldApplyOverflowClipping(this, aReflowState.mStyleDisplay)) {
nsMargin heightExtras = aReflowState.ComputedPhysicalBorderPadding();
if (GetSkipSides() & (1 << NS_SIDE_TOP)) {
heightExtras.top = 0;
LogicalMargin blockDirExtras = aReflowState.ComputedLogicalBorderPadding();
WritingMode wm = aReflowState.GetWritingMode();
if (GetLogicalSkipSides() & (LOGICAL_SIDE_B_START)) {
blockDirExtras.BStart(wm) = 0;
} else {
// Bottom margin never causes us to create continuations, so we
// don't need to worry about whether it fits in its entirety.
heightExtras.top += aReflowState.ComputedPhysicalMargin().top;
blockDirExtras.BStart(wm) +=
aReflowState.ComputedLogicalMargin().BStart(wm);
}
if (effectiveComputedHeight + heightExtras.TopBottom() <=
aReflowState.AvailableHeight()) {
if (effectiveComputedHeight + blockDirExtras.BStartEnd(wm) <=
aReflowState.AvailableBSize()) {
mutableReflowState.construct(aReflowState);
mutableReflowState.ref().AvailableHeight() = NS_UNCONSTRAINEDSIZE;
mutableReflowState.ref().AvailableBSize() = NS_UNCONSTRAINEDSIZE;
reflowState = mutableReflowState.addr();
}
}

7
layout/generic/nsFirstLetterFrame.cpp
View File

@ -380,7 +380,7 @@ nsFirstLetterFrame::GetBaseline() const
}
int
nsFirstLetterFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsFirstLetterFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
if (GetPrevContinuation()) {
// We shouldn't get calls to GetSkipSides for later continuations since
@ -388,10 +388,7 @@ nsFirstLetterFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
// properties that could trigger a call to GetSkipSides. Then again,
// it's not really an error to call GetSkipSides on any frame, so
// that's why we handle it properly.
return 1 << NS_SIDE_LEFT |
1 << NS_SIDE_RIGHT |
1 << NS_SIDE_TOP |
1 << NS_SIDE_BOTTOM;
return LOGICAL_SIDES_ALL;
}
return 0; // first continuation displays all sides
}

2
layout/generic/nsFirstLetterFrame.h
View File

@ -60,7 +60,7 @@ public:
virtual bool CanContinueTextRun() const MOZ_OVERRIDE;
virtual nscoord GetBaseline() const MOZ_OVERRIDE;
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
//override of nsFrame method
virtual nsresult GetChildFrameContainingOffset(int32_t inContentOffset,

76
layout/generic/nsFrame.cpp
View File

@ -944,19 +944,87 @@ nsIFrame::GetUsedPadding() const
return padding;
}
int
nsIFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
{
// Convert the logical skip sides to physical sides using the frame's
// writing mode
WritingMode writingMode = GetWritingMode();
int logicalSkip = GetLogicalSkipSides(aReflowState);
int skip = 0;
if (logicalSkip & LOGICAL_SIDE_B_START) {
if (writingMode.IsVertical()) {
skip |= 1 << (writingMode.IsVerticalLR() ? NS_SIDE_LEFT : NS_SIDE_RIGHT);
} else {
skip |= 1 << NS_SIDE_TOP;
}
}
if (logicalSkip & LOGICAL_SIDE_B_END) {
if (writingMode.IsVertical()) {
skip |= 1 << (writingMode.IsVerticalLR() ? NS_SIDE_RIGHT : NS_SIDE_LEFT);
} else {
skip |= 1 << NS_SIDE_BOTTOM;
}
}
if (logicalSkip & LOGICAL_SIDE_I_START) {
if (writingMode.IsVertical()) {
skip |= 1 << NS_SIDE_TOP;
} else {
skip |= 1 << (writingMode.IsBidiLTR() ? NS_SIDE_LEFT : NS_SIDE_RIGHT);
}
}
if (logicalSkip & LOGICAL_SIDE_I_END) {
if (writingMode.IsVertical()) {
skip |= 1 << NS_SIDE_BOTTOM;
} else {
skip |= 1 << (writingMode.IsBidiLTR() ? NS_SIDE_RIGHT : NS_SIDE_LEFT);
}
}
return skip;
}
void
nsIFrame::ApplySkipSides(nsMargin& aMargin,
const nsHTMLReflowState* aReflowState) const
{
int skipSides = GetSkipSides(aReflowState);
if (skipSides & (1 << NS_SIDE_TOP))
if (skipSides & (1 << NS_SIDE_TOP)) {
aMargin.top = 0;
if (skipSides & (1 << NS_SIDE_RIGHT))
}
if (skipSides & (1 << NS_SIDE_RIGHT)) {
aMargin.right = 0;
if (skipSides & (1 << NS_SIDE_BOTTOM))
}
if (skipSides & (1 << NS_SIDE_BOTTOM)) {
aMargin.bottom = 0;
if (skipSides & (1 << NS_SIDE_LEFT))
}
if (skipSides & (1 << NS_SIDE_LEFT)) {
aMargin.left = 0;
}
}
void
nsIFrame::ApplyLogicalSkipSides(LogicalMargin& aMargin,
const nsHTMLReflowState* aReflowState) const
{
int skipSides = GetLogicalSkipSides(aReflowState);
if (skipSides & (LOGICAL_SIDE_B_START)) {
aMargin.BStart(GetWritingMode()) = 0;
}
if (skipSides & (LOGICAL_SIDE_I_END)) {
aMargin.IEnd(GetWritingMode()) = 0;
}
if (skipSides & (LOGICAL_SIDE_B_END)) {
aMargin.BEnd(GetWritingMode()) = 0;
}
if (skipSides & (LOGICAL_SIDE_I_START)) {
aMargin.IStart(GetWritingMode()) = 0;
}
}
nsRect

10
layout/generic/nsFrameStateBits.h
View File

@ -507,15 +507,15 @@ FRAME_STATE_BIT(Image, 21, IMAGE_GOTINITIALREFLOW)
FRAME_STATE_GROUP(Inline, nsInlineFrame)
/** In Bidi left (or right) margin/padding/border should be applied to left
* (or right) most frame (or a continuation frame).
* This state value shows if this frame is left (or right) most continuation
/** In Bidi inline start (or end) margin/padding/border should be applied to
* first (or last) frame (or a continuation frame).
* This state value shows if this frame is first (or last) continuation
* or not.
*/
FRAME_STATE_BIT(Inline, 21, NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET)
FRAME_STATE_BIT(Inline, 22, NS_INLINE_FRAME_BIDI_VISUAL_IS_LEFT_MOST)
FRAME_STATE_BIT(Inline, 23, NS_INLINE_FRAME_BIDI_VISUAL_IS_RIGHT_MOST)
FRAME_STATE_BIT(Inline, 22, NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST)
FRAME_STATE_BIT(Inline, 23, NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST)
// == Frame state bits that apply to placeholder frames =======================

16
layout/generic/nsIFrame.h
View File

@ -934,6 +934,8 @@ public:
*/
void ApplySkipSides(nsMargin& aMargin,
const nsHTMLReflowState* aReflowState = nullptr) const;
void ApplyLogicalSkipSides(mozilla::LogicalMargin& aMargin,
const nsHTMLReflowState* aReflowState = nullptr) const;
/**
* Like the frame's rect (see |GetRect|), which is the border rect,
@ -2372,7 +2374,19 @@ public:
* passed in, indicating that it should be used to determine if sides
* should be skipped during reflow.
*/
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const { return 0; }
#define LOGICAL_SIDE_B_START 1
#define LOGICAL_SIDE_I_START 2
#define LOGICAL_SIDE_B_END 4
#define LOGICAL_SIDE_I_END 8
#define LOGICAL_SIDES_I_BOTH (LOGICAL_SIDE_I_START | LOGICAL_SIDE_I_END)
#define LOGICAL_SIDES_B_BOTH (LOGICAL_SIDE_B_START | LOGICAL_SIDE_B_END)
#define LOGICAL_SIDES_ALL (LOGICAL_SIDE_I_START | LOGICAL_SIDE_I_END | \
LOGICAL_SIDE_B_START | LOGICAL_SIDE_B_END)
int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const;
virtual int
GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const {
return 0;
}
/**
* @returns true if this frame is selected.

6
layout/generic/nsImageFrame.cpp
View File

@ -1780,14 +1780,14 @@ nsImageFrame::List(FILE* out, const char* aPrefix, uint32_t aFlags) const
#endif
int
nsImageFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsImageFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
int skip = 0;
if (nullptr != GetPrevInFlow()) {
skip |= 1 << NS_SIDE_TOP;
skip |= LOGICAL_SIDE_B_START;
}
if (nullptr != GetNextInFlow()) {
skip |= 1 << NS_SIDE_BOTTOM;
skip |= LOGICAL_SIDE_B_END;
}
return skip;
}

2
layout/generic/nsImageFrame.h
View File

@ -114,7 +114,7 @@ public:
uint32_t aFlags = 0) const MOZ_OVERRIDE;
#endif
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
nsresult GetIntrinsicImageSize(nsSize& aSize);

27
layout/generic/nsInlineFrame.cpp
View File

@ -866,32 +866,32 @@ nsInlineFrame::PushFrames(nsPresContext* aPresContext,
//////////////////////////////////////////////////////////////////////
int
nsInlineFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsInlineFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
int skip = 0;
if (!IsLeftMost()) {
if (!IsFirst()) {
nsInlineFrame* prev = (nsInlineFrame*) GetPrevContinuation();
if ((GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET) ||
(prev && (prev->mRect.height || prev->mRect.width))) {
// Prev continuation is not empty therefore we don't render our left
// Prev continuation is not empty therefore we don't render our start
// border edge.
skip |= 1 << NS_SIDE_LEFT;
skip |= LOGICAL_SIDE_I_START;
}
else {
// If the prev continuation is empty, then go ahead and let our left
// If the prev continuation is empty, then go ahead and let our start
// edge border render.
}
}
if (!IsRightMost()) {
if (!IsLast()) {
nsInlineFrame* next = (nsInlineFrame*) GetNextContinuation();
if ((GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET) ||
(next && (next->mRect.height || next->mRect.width))) {
// Next continuation is not empty therefore we don't render our right
// Next continuation is not empty therefore we don't render our end
// border edge.
skip |= 1 << NS_SIDE_RIGHT;
skip |= LOGICAL_SIDE_I_END;
}
else {
// If the next continuation is empty, then go ahead and let our right
// If the next continuation is empty, then go ahead and let our end
// edge border render.
}
}
@ -902,18 +902,15 @@ nsInlineFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
// a split should skip the "start" side. But figuring out which part of
// the split we are involves getting our first continuation, which might be
// expensive. So don't bother if we already have the relevant bits set.
bool ltr = (NS_STYLE_DIRECTION_LTR == StyleVisibility()->mDirection);
int startBit = (1 << (ltr ? NS_SIDE_LEFT : NS_SIDE_RIGHT));
int endBit = (1 << (ltr ? NS_SIDE_RIGHT : NS_SIDE_LEFT));
if (((startBit | endBit) & skip) != (startBit | endBit)) {
if (skip != LOGICAL_SIDES_I_BOTH) {
// We're missing one of the skip bits, so check whether we need to set it.
// Only get the first continuation once, as an optimization.
nsIFrame* firstContinuation = FirstContinuation();
if (firstContinuation->FrameIsNonLastInIBSplit()) {
skip |= endBit;
skip |= LOGICAL_SIDE_I_END;
}
if (firstContinuation->FrameIsNonFirstInIBSplit()) {
skip |= startBit;
skip |= LOGICAL_SIDE_I_START;
}
}
}

18
layout/generic/nsInlineFrame.h
View File

@ -84,24 +84,24 @@ public:
virtual bool DrainSelfOverflowList() MOZ_OVERRIDE;
/**
* Return true if the frame is leftmost frame or continuation.
* Return true if the frame is first visual frame or first continuation
*/
bool IsLeftMost() const {
// If the frame's bidi visual state is set, return is-leftmost state
bool IsFirst() const {
// If the frame's bidi visual state is set, return is-first state
// else return true if it's the first continuation.
return (GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET)
? !!(GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_IS_LEFT_MOST)
? !!(GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST)
: (!GetPrevInFlow());
}
/**
* Return true if the frame is rightmost frame or continuation.
* Return true if the frame is last visual frame or last continuation.
*/
bool IsRightMost() const {
// If the frame's bidi visual state is set, return is-rightmost state
bool IsLast() const {
// If the frame's bidi visual state is set, return is-last state
// else return true if it's the last continuation.
return (GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET)
? !!(GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_IS_RIGHT_MOST)
? !!(GetStateBits() & NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST)
: (!GetNextInFlow());
}
@ -126,7 +126,7 @@ protected:
nsInlineFrame(nsStyleContext* aContext) : nsContainerFrame(aContext) {}
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
nsresult ReflowFrames(nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,

10
layout/generic/nsSplittableFrame.cpp
View File

@ -247,16 +247,16 @@ nsSplittableFrame::GetEffectiveComputedHeight(const nsHTMLReflowState& aReflowSt
}
int
nsSplittableFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsSplittableFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
if (IS_TRUE_OVERFLOW_CONTAINER(this)) {
return (1 << NS_SIDE_TOP) | (1 << NS_SIDE_BOTTOM);
return LOGICAL_SIDES_B_BOTH;
}
int skip = 0;
if (GetPrevInFlow()) {
skip |= 1 << NS_SIDE_TOP;
skip |= LOGICAL_SIDE_B_START;
}
if (aReflowState) {
@ -270,13 +270,13 @@ nsSplittableFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
if (effectiveCH > aReflowState->AvailableHeight()) {
// Our content height is going to exceed our available height, so we're
// going to need a next-in-flow.
skip |= 1 << NS_SIDE_BOTTOM;
skip |= LOGICAL_SIDE_B_END;
}
}
} else {
nsIFrame* nif = GetNextInFlow();
if (nif && !IS_TRUE_OVERFLOW_CONTAINER(nif)) {
skip |= 1 << NS_SIDE_BOTTOM;
skip |= LOGICAL_SIDE_B_END;
}
}

6
layout/generic/nsSplittableFrame.h
View File

@ -93,10 +93,10 @@ protected:
nscoord aConsumed = NS_INTRINSICSIZE) const;
/**
* @see nsIFrame::GetSkipSides()
* @see nsIFrame::ApplySkipSides()
* @see nsIFrame::GetLogicalSkipSides()
* @see nsIFrame::ApplyLogicalSkipSides()
*/
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
#ifdef DEBUG
virtual void DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent) MOZ_OVERRIDE;

6
layout/tables/nsTableCellFrame.cpp
View File

@ -548,14 +548,14 @@ nsTableCellFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
}
int
nsTableCellFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsTableCellFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
int skip = 0;
if (nullptr != GetPrevInFlow()) {
skip |= 1 << NS_SIDE_TOP;
skip |= LOGICAL_SIDE_B_START;
}
if (nullptr != GetNextInFlow()) {
skip |= 1 << NS_SIDE_BOTTOM;
skip |= LOGICAL_SIDE_B_END;
}
return skip;
}

2
layout/tables/nsTableCellFrame.h
View File

@ -221,7 +221,7 @@ public:
virtual void InvalidateFrameForRemoval() MOZ_OVERRIDE { InvalidateFrameSubtree(); }
protected:
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState= nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState= nullptr) const MOZ_OVERRIDE;
/**
* GetBorderOverflow says how far the cell's own borders extend

6
layout/tables/nsTableColGroupFrame.cpp
View File

@ -341,14 +341,14 @@ nsTableColGroupFrame::RemoveFrame(ChildListID aListID,
}
int
nsTableColGroupFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsTableColGroupFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
int skip = 0;
if (nullptr != GetPrevInFlow()) {
skip |= 1 << NS_SIDE_TOP;
skip |= 1 << LOGICAL_SIDE_B_START;
}
if (nullptr != GetNextInFlow()) {
skip |= 1 << NS_SIDE_BOTTOM;
skip |= 1 << LOGICAL_SIDE_B_END;
}
return skip;
}

2
layout/tables/nsTableColGroupFrame.h
View File

@ -212,7 +212,7 @@ protected:
void InsertColsReflow(int32_t aColIndex,
const nsFrameList::Slice& aCols);
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
// data members
int32_t mColCount;

6
layout/tables/nsTableFrame.cpp
View File

@ -1407,16 +1407,16 @@ nsTableFrame::PaintTableBorderBackground(nsRenderingContext& aRenderingContext,
}
int
nsTableFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsTableFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
int skip = 0;
// frame attribute was accounted for in nsHTMLTableElement::MapTableBorderInto
// account for pagination
if (nullptr != GetPrevInFlow()) {
skip |= 1 << NS_SIDE_TOP;
skip |= LOGICAL_SIDE_B_START;
}
if (nullptr != GetNextInFlow()) {
skip |= 1 << NS_SIDE_BOTTOM;
skip |= LOGICAL_SIDE_B_END;
}
return skip;
}

2
layout/tables/nsTableFrame.h
View File

@ -527,7 +527,7 @@ protected:
void InitChildReflowState(nsHTMLReflowState& aReflowState);
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
public:
bool IsRowInserted() const;

6
layout/tables/nsTableRowFrame.cpp
View File

@ -603,14 +603,14 @@ nsTableRowFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
}
int
nsTableRowFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsTableRowFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
int skip = 0;
if (nullptr != GetPrevInFlow()) {
skip |= 1 << NS_SIDE_TOP;
skip |= LOGICAL_SIDE_B_START;
}
if (nullptr != GetNextInFlow()) {
skip |= 1 << NS_SIDE_BOTTOM;
skip |= LOGICAL_SIDE_B_END;
}
return skip;
}

2
layout/tables/nsTableRowFrame.h
View File

@ -243,7 +243,7 @@ protected:
bool aBorderCollapse,
nsTableCellReflowState& aReflowState);
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
// row-specific methods

6
layout/tables/nsTableRowGroupFrame.cpp
View File

@ -254,14 +254,14 @@ nsTableRowGroupFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
}
int
nsTableRowGroupFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const
nsTableRowGroupFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const
{
int skip = 0;
if (nullptr != GetPrevInFlow()) {
skip |= 1 << NS_SIDE_TOP;
skip |= LOGICAL_SIDE_B_START;
}
if (nullptr != GetNextInFlow()) {
skip |= 1 << NS_SIDE_BOTTOM;
skip |= LOGICAL_SIDE_B_END;
}
return skip;
}

2
layout/tables/nsTableRowGroupFrame.h
View File

@ -337,7 +337,7 @@ protected:
bool aBorderCollapse,
nsHTMLReflowState& aReflowState);
virtual int GetSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
void PlaceChild(nsPresContext* aPresContext,
nsRowGroupReflowState& aReflowState,