зеркало из https://github.com/mozilla/gecko-dev.git
Bug 91419 patch 9: Fix comments and debugging output referring to "special" frames. r=mats
This commit is contained in:
L. David Baron
Родитель
f47695e72d
Коммит
d31701cad1
|
|
@ -708,9 +708,11 @@ RestyleManager::ProcessRestyledFrames(nsStyleChangeList& aChangeList)
|
|||
nsIFrame* hintFrame = GetFrameForChildrenOnlyTransformHint(frame);
|
||||
nsIFrame* childFrame = hintFrame->GetFirstPrincipalChild();
|
||||
NS_ASSERTION(!nsLayoutUtils::GetNextContinuationOrIBSplitSibling(frame),
|
||||
"SVG frames should not have continuations or special siblings");
|
||||
"SVG frames should not have continuations "
|
||||
"or ib-split siblings");
|
||||
NS_ASSERTION(!nsLayoutUtils::GetNextContinuationOrIBSplitSibling(hintFrame),
|
||||
"SVG frames should not have continuations or special siblings");
|
||||
"SVG frames should not have continuations "
|
||||
"or ib-split siblings");
|
||||
for ( ; childFrame; childFrame = childFrame->GetNextSibling()) {
|
||||
NS_ABORT_IF_FALSE(childFrame->IsFrameOfType(nsIFrame::eSVG),
|
||||
"Not expecting non-SVG children");
|
||||
|
|
@ -721,7 +723,8 @@ RestyleManager::ProcessRestyledFrames(nsStyleChangeList& aChangeList)
|
|||
mOverflowChangedTracker.AddFrame(childFrame);
|
||||
}
|
||||
NS_ASSERTION(!nsLayoutUtils::GetNextContinuationOrIBSplitSibling(childFrame),
|
||||
"SVG frames should not have continuations or special siblings");
|
||||
"SVG frames should not have continuations "
|
||||
"or ib-split siblings");
|
||||
NS_ASSERTION(childFrame->GetParent() == hintFrame,
|
||||
"SVG child frame not expected to have different parent");
|
||||
}
|
||||
|
|
@ -1009,7 +1012,7 @@ RestyleManager::AttributeChanged(Element* aElement,
|
|||
|
||||
// let the frame deal with it now, so we don't have to deal later
|
||||
primaryFrame->AttributeChanged(aNameSpaceID, aAttribute, aModType);
|
||||
// XXXwaterson should probably check for special IB siblings
|
||||
// XXXwaterson should probably check for IB split siblings
|
||||
// here, and propagate the AttributeChanged notification to
|
||||
// them, as well. Currently, inline frames don't do anything on
|
||||
// this notification, so it's not that big a deal.
|
||||
|
|
@ -1773,16 +1776,18 @@ static nsIFrame*
|
|||
GetPrevContinuationWithPossiblySameStyle(nsIFrame* aFrame)
|
||||
{
|
||||
// Account for {ib} splits when looking for "prevContinuation". In
|
||||
// particular, for the first-continuation of a part of an {ib} split we
|
||||
// want to use the special prevsibling of the special prevsibling of
|
||||
// aFrame, which should have the same style context as aFrame itself.
|
||||
// In particular, if aFrame is the first continuation of an inline part
|
||||
// of an {ib} split then its special prevsibling is a block, and the
|
||||
// special prevsibling of _that_ is an inline, just like aFrame.
|
||||
// Similarly, if aFrame is the first continuation of a block part of an
|
||||
// {ib} split (an {ib} wrapper block), then its special prevsibling is
|
||||
// an inline and the special prevsibling of that is either another {ib}
|
||||
// wrapper block block or null.
|
||||
// particular, for the first-continuation of a part of an {ib} split
|
||||
// we want to use the previous ib-split sibling of the previous
|
||||
// ib-split sibling of aFrame, which should have the same style
|
||||
// context as aFrame itself. In particular, if aFrame is the first
|
||||
// continuation of an inline part of a block-in-inline split then its
|
||||
// previous ib-split sibling is a block, and the previous ib-split
|
||||
// sibling of _that_ is an inline, just like aFrame. Similarly, if
|
||||
// aFrame is the first continuation of a block part of an
|
||||
// block-in-inline split (a block-in-inline wrapper block), then its
|
||||
// previous ib-split sibling is an inline and the previous ib-split
|
||||
// sibling of that is either another block-in-inline wrapper block box
|
||||
// or null.
|
||||
nsIFrame *prevContinuation = aFrame->GetPrevContinuation();
|
||||
if (!prevContinuation &&
|
||||
(aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) {
|
||||
|
|
@ -1804,7 +1809,7 @@ GetPrevContinuationWithPossiblySameStyle(nsIFrame* aFrame)
|
|||
}
|
||||
|
||||
/**
|
||||
* Get the previous continuation or similar special sibling (assuming
|
||||
* Get the previous continuation or similar ib-split sibling (assuming
|
||||
* block/inline alternation), conditionally on it having the same style.
|
||||
* This assumes that we're not between resolving the two (i.e., that
|
||||
* they're both already resolved.
|
||||
|
|
@ -1829,7 +1834,7 @@ GetPrevContinuationWithSameStyle(nsIFrame* aFrame)
|
|||
}
|
||||
|
||||
/**
|
||||
* Get the next continuation or similar special sibling (assuming
|
||||
* Get the next continuation or similar ib-split sibling (assuming
|
||||
* block/inline alternation), conditionally on it having the same style.
|
||||
*
|
||||
* Since this is used when deciding to copy the new style context, it
|
||||
|
|
@ -2202,7 +2207,7 @@ ElementRestyler::CaptureChange(nsStyleContext* aOldContext,
|
|||
/**
|
||||
* Recompute style for mFrame (which should not have a prev continuation
|
||||
* with the same style), all of its next continuations with the same
|
||||
* style, and all special siblings of the same type (either block or
|
||||
* style, and all ib-split siblings of the same type (either block or
|
||||
* inline, skipping the intermediates of the other type) and accumulate
|
||||
* changes into mChangeList given that mHintsHandled is already accumulated
|
||||
* for an ancestor.
|
||||
|
|
@ -2840,7 +2845,7 @@ GetNextBlockInInlineSibling(FramePropertyTable* aPropTable, nsIFrame* aFrame)
|
|||
{
|
||||
NS_ASSERTION(!aFrame->GetPrevContinuation(),
|
||||
"must start with the first continuation");
|
||||
// Might we have special siblings?
|
||||
// Might we have ib-split siblings?
|
||||
if (!(aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) {
|
||||
// nothing more to do here
|
||||
return nullptr;
|
||||
|
|
@ -2868,7 +2873,7 @@ RestyleManager::ComputeStyleChangeFor(nsIFrame* aFrame,
|
|||
"must start with the first continuation");
|
||||
|
||||
// We want to start with this frame and walk all its next-in-flows,
|
||||
// as well as all its special siblings and their next-in-flows,
|
||||
// as well as all its ib-split siblings and their next-in-flows,
|
||||
// reresolving style on all the frames we encounter in this walk that
|
||||
// we didn't reach already. In the normal case, this will mean only
|
||||
// restyling the first two block-in-inline splits and no
|
||||
|
|
@ -2890,7 +2895,7 @@ RestyleManager::ComputeStyleChangeFor(nsIFrame* aFrame,
|
|||
nsTArray<nsIContent*> visibleKidsOfHiddenElement;
|
||||
for (nsIFrame* ibSibling = aFrame; ibSibling;
|
||||
ibSibling = GetNextBlockInInlineSibling(propTable, ibSibling)) {
|
||||
// Outer loop over special siblings
|
||||
// Outer loop over ib-split siblings
|
||||
for (nsIFrame* cont = ibSibling; cont; cont = cont->GetNextContinuation()) {
|
||||
if (GetPrevContinuationWithSameStyle(cont)) {
|
||||
// We already handled this element when dealing with its earlier
|
||||
|
|
@ -2908,7 +2913,7 @@ RestyleManager::ComputeStyleChangeFor(nsIFrame* aFrame,
|
|||
|
||||
if (restyler.HintsHandledForFrame() & nsChangeHint_ReconstructFrame) {
|
||||
// If it's going to cause a framechange, then don't bother
|
||||
// with the continuations or special siblings since they'll be
|
||||
// with the continuations or ib-split siblings since they'll be
|
||||
// clobbered by the frame reconstruct anyway.
|
||||
NS_ASSERTION(!cont->GetPrevContinuation(),
|
||||
"continuing frame had more severe impact than first-in-flow");
|
||||
|
|
|
|||
|
|
@ -420,7 +420,7 @@ static nsIFrame* GetIBSplitSibling(nsIFrame* aFrame)
|
|||
{
|
||||
NS_PRECONDITION(IsFramePartOfIBSplit(aFrame), "Shouldn't call this");
|
||||
|
||||
// We only store the "special sibling" annotation with the first
|
||||
// We only store the "ib-split sibling" annotation with the first
|
||||
// frame in the continuation chain. Walk back to find that frame now.
|
||||
return static_cast<nsIFrame*>
|
||||
(aFrame->FirstContinuation()->
|
||||
|
|
@ -431,7 +431,7 @@ static nsIFrame* GetIBSplitPrevSibling(nsIFrame* aFrame)
|
|||
{
|
||||
NS_PRECONDITION(IsFramePartOfIBSplit(aFrame), "Shouldn't call this");
|
||||
|
||||
// We only store the "special sibling" annotation with the first
|
||||
// We only store the ib-split sibling annotation with the first
|
||||
// frame in the continuation chain. Walk back to find that frame now.
|
||||
return static_cast<nsIFrame*>
|
||||
(aFrame->FirstContinuation()->
|
||||
|
|
@ -462,20 +462,20 @@ SetFrameIsIBSplit(nsIFrame* aFrame, nsIFrame* aIBSplitSibling)
|
|||
|
||||
// We should be the only continuation
|
||||
NS_ASSERTION(!aFrame->GetPrevContinuation(),
|
||||
"assigning special sibling to other than first continuation!");
|
||||
"assigning ib-split sibling to other than first continuation!");
|
||||
NS_ASSERTION(!aFrame->GetNextContinuation() ||
|
||||
IsFramePartOfIBSplit(aFrame->GetNextContinuation()),
|
||||
"should have no non-special continuations here");
|
||||
"should have no non-ib-split continuations here");
|
||||
|
||||
// Mark the frame as "special".
|
||||
// Mark the frame as ib-split.
|
||||
aFrame->AddStateBits(NS_FRAME_PART_OF_IBSPLIT);
|
||||
|
||||
if (aIBSplitSibling) {
|
||||
NS_ASSERTION(!aIBSplitSibling->GetPrevContinuation(),
|
||||
"assigning something other than the first continuation as the "
|
||||
"special sibling");
|
||||
"ib-split sibling");
|
||||
|
||||
// Store the "special sibling" (if we were given one) with the
|
||||
// Store the ib-split sibling (if we were given one) with the
|
||||
// first frame in the flow.
|
||||
FramePropertyTable* props = aFrame->PresContext()->PropertyTable();
|
||||
props->Set(aFrame, nsIFrame::IBSplitSibling(), aIBSplitSibling);
|
||||
|
|
@ -499,9 +499,9 @@ GetIBContainingBlockFor(nsIFrame* aFrame)
|
|||
return aFrame;
|
||||
}
|
||||
|
||||
// Note that we ignore non-special frames which have a pseudo on their
|
||||
// Note that we ignore non-ib-split frames which have a pseudo on their
|
||||
// style context -- they're not the frames we're looking for! In
|
||||
// particular, they may be hiding a real parent that _is_ special.
|
||||
// particular, they may be hiding a real parent that _is_ in an ib-split.
|
||||
if (!IsFramePartOfIBSplit(parentFrame) &&
|
||||
!parentFrame->StyleContext()->GetPseudo())
|
||||
break;
|
||||
|
|
@ -510,7 +510,8 @@ GetIBContainingBlockFor(nsIFrame* aFrame)
|
|||
} while (1);
|
||||
|
||||
// post-conditions
|
||||
NS_ASSERTION(parentFrame, "no normal ancestor found for special frame in GetIBContainingBlockFor");
|
||||
NS_ASSERTION(parentFrame, "no normal ancestor found for ib-split frame "
|
||||
"in GetIBContainingBlockFor");
|
||||
NS_ASSERTION(parentFrame != aFrame, "parentFrame is actually the child frame - bogus reslt");
|
||||
|
||||
return parentFrame;
|
||||
|
|
@ -5743,7 +5744,7 @@ AdjustAppendParentForAfterContent(nsPresContext* aPresContext,
|
|||
// empty. Since we have no ::after pseudo-element, we do in fact want to be
|
||||
// appending to that last part, so advance to it if needed. Note that here
|
||||
// aParentFrame is the result of a GetLastIBSplitSibling call, so must be
|
||||
// either the last or next to last special sibling.
|
||||
// either the last or next to last ib-split sibling.
|
||||
nsIFrame* trailingInline = GetIBSplitSibling(aParentFrame);
|
||||
if (trailingInline) {
|
||||
aParentFrame = trailingInline;
|
||||
|
|
@ -5751,7 +5752,7 @@ AdjustAppendParentForAfterContent(nsPresContext* aPresContext,
|
|||
|
||||
// Always make sure to look at the last continuation of the frame
|
||||
// for the {ib} case, even if that continuation is empty. We
|
||||
// don't do this for the non-special-frame case, since in the
|
||||
// don't do this for the non-ib-split-frame case, since in the
|
||||
// other cases appending to the last nonempty continuation is fine
|
||||
// and in fact not doing that can confuse code that doesn't know
|
||||
// to pull kids from continuations other than its next one.
|
||||
|
|
@ -5811,7 +5812,7 @@ nsCSSFrameConstructor::AppendFramesToParent(nsFrameConstructorState& aStat
|
|||
NS_PRECONDITION(!IsFramePartOfIBSplit(aParentFrame) ||
|
||||
!GetIBSplitSibling(aParentFrame) ||
|
||||
!GetIBSplitSibling(aParentFrame)->GetFirstPrincipalChild(),
|
||||
"aParentFrame has a special sibling with kids?");
|
||||
"aParentFrame has a ib-split sibling with kids?");
|
||||
NS_PRECONDITION(!aPrevSibling || aPrevSibling->GetParent() == aParentFrame,
|
||||
"Parent and prevsibling don't match");
|
||||
|
||||
|
|
@ -6008,7 +6009,7 @@ nsCSSFrameConstructor::FindFrameForContentSibling(nsIContent* aContent,
|
|||
NS_ASSERTION(!sibling->GetPrevContinuation(), "How did that happen?");
|
||||
|
||||
if (aPrevSibling) {
|
||||
// The frame may be a special frame (a split inline frame that
|
||||
// The frame may be a ib-split frame (a split inline frame that
|
||||
// contains a block). Get the last part of that split.
|
||||
if (IsFramePartOfIBSplit(sibling)) {
|
||||
sibling = GetLastIBSplitSibling(sibling, true);
|
||||
|
|
@ -6636,16 +6637,16 @@ nsCSSFrameConstructor::ContentAppended(nsIContent* aContainer,
|
|||
return rv;
|
||||
}
|
||||
|
||||
// If the frame we are manipulating is a ``special'' frame (that is, one
|
||||
// If the frame we are manipulating is a ib-split frame (that is, one
|
||||
// that's been created as a result of a block-in-inline situation) then we
|
||||
// need to append to the last special sibling, not to the frame itself.
|
||||
// need to append to the last ib-split sibling, not to the frame itself.
|
||||
bool parentIBSplit = IsFramePartOfIBSplit(parentFrame);
|
||||
if (parentIBSplit) {
|
||||
#ifdef DEBUG
|
||||
if (gNoisyContentUpdates) {
|
||||
printf("nsCSSFrameConstructor::ContentAppended: parentFrame=");
|
||||
nsFrame::ListTag(stdout, parentFrame);
|
||||
printf(" is special\n");
|
||||
printf(" is ib-split\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -6725,7 +6726,7 @@ nsCSSFrameConstructor::ContentAppended(nsIContent* aContainer,
|
|||
nsIFrame* prevSibling = ::FindAppendPrevSibling(parentFrame, parentAfterFrame);
|
||||
|
||||
// Perform special check for diddling around with the frames in
|
||||
// a special inline frame.
|
||||
// a ib-split inline frame.
|
||||
// If we're appending before :after content, then we're not really
|
||||
// appending, so let WipeContainingBlock know that.
|
||||
LAYOUT_PHASE_TEMP_EXIT();
|
||||
|
|
@ -7292,7 +7293,7 @@ nsCSSFrameConstructor::ContentRangeInserted(nsIContent* aContainer,
|
|||
// (bug 341858).
|
||||
// This can affect our prevSibling and isAppend, but should not have any
|
||||
// effect on the WipeContainingBlock above, since this should only happen
|
||||
// when neither parent is a special frame and should not affect whitespace
|
||||
// when neither parent is a ib-split frame and should not affect whitespace
|
||||
// handling inside table-related frames (and in fact, can only happen when
|
||||
// one of the parents is an outer table and one is an inner table or when the
|
||||
// parent is a fieldset or fieldset content frame). So it won't affect the
|
||||
|
|
@ -7310,7 +7311,7 @@ nsCSSFrameConstructor::ContentRangeInserted(nsIContent* aContainer,
|
|||
nsIFrame* frame2 = prevSibling->GetParent();
|
||||
NS_ASSERTION(!IsFramePartOfIBSplit(frame1) &&
|
||||
!IsFramePartOfIBSplit(frame2),
|
||||
"Neither should be special");
|
||||
"Neither should be ib-split");
|
||||
NS_ASSERTION((frame1->GetType() == nsGkAtoms::tableFrame &&
|
||||
frame2->GetType() == nsGkAtoms::tableOuterFrame) ||
|
||||
(frame1->GetType() == nsGkAtoms::tableOuterFrame &&
|
||||
|
|
@ -8430,7 +8431,7 @@ nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame,
|
|||
printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: "
|
||||
"frame=");
|
||||
nsFrame::ListTag(stdout, aFrame);
|
||||
printf(" is special\n");
|
||||
printf(" is ib-split\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -8564,7 +8565,7 @@ nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame,
|
|||
}
|
||||
|
||||
// We might still need to reconstruct things if the parent of inFlowFrame is
|
||||
// special, since in that case the removal of aFrame might affect the
|
||||
// ib-split, since in that case the removal of aFrame might affect the
|
||||
// splitting of its parent.
|
||||
if (!IsFramePartOfIBSplit(parent)) {
|
||||
return false;
|
||||
|
|
@ -8591,7 +8592,7 @@ nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame,
|
|||
printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: "
|
||||
"frame=");
|
||||
nsFrame::ListTag(stdout, parent);
|
||||
printf(" is special\n");
|
||||
printf(" is ib-split\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -8612,7 +8613,7 @@ nsCSSFrameConstructor::RecreateFramesForContent(nsIContent* aContent,
|
|||
// frame tree for chrome (see bug 157322).
|
||||
NS_ENSURE_TRUE(aContent->GetDocument(), NS_ERROR_FAILURE);
|
||||
|
||||
// Is the frame `special'? If so, we need to reframe the containing
|
||||
// Is the frame ib-split? If so, we need to reframe the containing
|
||||
// block *here*, rather than trying to remove and re-insert the
|
||||
// content (which would otherwise result in *two* nested reframe
|
||||
// containing block from ContentRemoved() and ContentInserted(),
|
||||
|
|
@ -10693,7 +10694,7 @@ nsCSSFrameConstructor::BuildInlineChildItems(nsFrameConstructorState& aState,
|
|||
|
||||
// return whether it's ok to append (in the AppendFrames sense) to
|
||||
// aParentFrame if our nextSibling is aNextSibling. aParentFrame must
|
||||
// be an {ib} special inline.
|
||||
// be an ib-split inline.
|
||||
static bool
|
||||
IsSafeToAppendToIBSplitInline(nsIFrame* aParentFrame, nsIFrame* aNextSibling)
|
||||
{
|
||||
|
|
@ -10701,7 +10702,7 @@ IsSafeToAppendToIBSplitInline(nsIFrame* aParentFrame, nsIFrame* aNextSibling)
|
|||
"Must have an inline parent here");
|
||||
do {
|
||||
NS_ASSERTION(IsFramePartOfIBSplit(aParentFrame),
|
||||
"How is this not special?");
|
||||
"How is this not part of an ib-split?");
|
||||
if (aNextSibling || aParentFrame->GetNextContinuation() ||
|
||||
GetIBSplitSibling(aParentFrame)) {
|
||||
return false;
|
||||
|
|
@ -10995,7 +10996,8 @@ nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
|
|||
break;
|
||||
}
|
||||
|
||||
// Now we know we have a block parent. If it's not special, we're all set.
|
||||
// Now we know we have a block parent. If it's not part of an
|
||||
// ib-split, we're all set.
|
||||
if (!IsFramePartOfIBSplit(aFrame)) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -11017,7 +11019,7 @@ nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
|
|||
|
||||
// To find the right block to reframe, just walk up the tree until we find a
|
||||
// frame that is:
|
||||
// 1) Not part of an IB split (not special)
|
||||
// 1) Not part of an IB split
|
||||
// 2) Not a pseudo-frame
|
||||
// 3) Not an inline frame
|
||||
// We're guaranteed to find one, since nsStyleContext::ApplyStyleFixups
|
||||
|
|
@ -11032,8 +11034,8 @@ nsCSSFrameConstructor::WipeContainingBlock(nsFrameConstructorState& aState,
|
|||
aContainingBlock->StyleContext()->GetPseudo()) {
|
||||
aContainingBlock = aContainingBlock->GetParent();
|
||||
NS_ASSERTION(aContainingBlock,
|
||||
"Must have non-inline, non-special, non-pseudo frame as root "
|
||||
"(or child of root, for a table root)!");
|
||||
"Must have non-inline, non-ib-split, non-pseudo frame as "
|
||||
"root (or child of root, for a table root)!");
|
||||
}
|
||||
|
||||
// Tell parent of the containing block to reformulate the
|
||||
|
|
@ -11058,7 +11060,7 @@ nsCSSFrameConstructor::ReframeContainingBlock(nsIFrame* aFrame)
|
|||
#ifdef DEBUG
|
||||
// ReframeContainingBlock is a NASTY routine, it causes terrible performance problems
|
||||
// so I want to see when it is happening! Unfortunately, it is happening way to often because
|
||||
// so much content on the web causes 'special' block-in-inline frame situations and we handle them
|
||||
// so much content on the web causes block-in-inline frame situations and we handle them
|
||||
// very poorly
|
||||
if (gNoisyContentUpdates) {
|
||||
printf("nsCSSFrameConstructor::ReframeContainingBlock frame=%p\n",
|
||||
|
|
|
|||
|
|
@ -369,7 +369,7 @@ private:
|
|||
FrameConstructionItemList& aItems);
|
||||
|
||||
// This method can change aFrameList: it can chop off the beginning and put
|
||||
// it in aParentFrame while putting the remainder into a special sibling of
|
||||
// it in aParentFrame while putting the remainder into a ib-split sibling of
|
||||
// aParentFrame. aPrevSibling must be the frame after which aFrameList is to
|
||||
// be placed on aParentFrame's principal child list. It may be null if
|
||||
// aFrameList is being added at the beginning of the child list.
|
||||
|
|
|
|||
|
|
@ -99,7 +99,7 @@ struct InlineBackgroundData
|
|||
nscoord curOffset = aFrame->GetOffsetTo(mBlockFrame).x;
|
||||
|
||||
// No need to use our GetPrevContinuation/GetNextContinuation methods
|
||||
// here, since ib special siblings are certainly not on the same line.
|
||||
// here, since ib-split siblings are certainly not on the same line.
|
||||
|
||||
nsIFrame* inlineFrame = aFrame->GetPrevContinuation();
|
||||
// If the continuation is fluid we know inlineFrame is not on the same line.
|
||||
|
|
|
|||
|
|
@ -2728,7 +2728,7 @@ nsLayoutUtils::GetNextContinuationOrIBSplitSibling(nsIFrame *aFrame)
|
|||
return result;
|
||||
|
||||
if ((aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) != 0) {
|
||||
// We only store the "special sibling" annotation with the first
|
||||
// We only store the ib-split sibling annotation with the first
|
||||
// frame in the continuation chain. Walk back to find that frame now.
|
||||
aFrame = aFrame->FirstContinuation();
|
||||
|
||||
|
|
|
|||
|
|
@ -1011,13 +1011,14 @@ public:
|
|||
static nsIFrame* GetParentOrPlaceholderForCrossDoc(nsIFrame* aFrame);
|
||||
|
||||
/**
|
||||
* Get a frame's next-in-flow, or, if it doesn't have one, its special sibling.
|
||||
* Get a frame's next-in-flow, or, if it doesn't have one, its
|
||||
* block-in-inline-split sibling.
|
||||
*/
|
||||
static nsIFrame*
|
||||
GetNextContinuationOrIBSplitSibling(nsIFrame *aFrame);
|
||||
|
||||
/**
|
||||
* Get the first frame in the continuation-plus-special-sibling chain
|
||||
* Get the first frame in the continuation-plus-ib-split-sibling chain
|
||||
* containing aFrame.
|
||||
*/
|
||||
static nsIFrame*
|
||||
|
|
|
|||
|
|
@ -357,7 +357,7 @@ StickyScrollContainer::UpdatePositions(nsPoint aScrollPosition,
|
|||
nsIFrame* f = mFrames[i];
|
||||
if (!nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(f)) {
|
||||
// This frame was added in nsFrame::Init before we knew it wasn't
|
||||
// the first special-sibling.
|
||||
// the first ib-split-sibling.
|
||||
mFrames.RemoveElementAt(i);
|
||||
--i;
|
||||
continue;
|
||||
|
|
|
|||
|
|
@ -500,7 +500,7 @@ nsFrame::Init(nsIContent* aContent,
|
|||
!(mState & NS_FRAME_IS_NONDISPLAY) &&
|
||||
!disp->IsInnerTableStyle()) {
|
||||
// Note that we only add first continuations, but we really only
|
||||
// want to add first continuation-or-special-siblings. But since we
|
||||
// want to add first continuation-or-ib-split-siblings. But since we
|
||||
// don't yet know if we're a later part of a block-in-inline split,
|
||||
// we'll just add later members of a block-in-inline split here, and
|
||||
// then StickyScrollContainer will remove them later.
|
||||
|
|
@ -619,7 +619,7 @@ nsFrame::DestroyFrom(nsIFrame* aDestructRoot)
|
|||
}
|
||||
}
|
||||
|
||||
// If we have any IB split special siblings, clear their references to us.
|
||||
// If we have any IB split siblings, clear their references to us.
|
||||
// (Note: This has to happen before we call shell->NotifyDestroyingFrame,
|
||||
// because that clears our Properties() table.)
|
||||
if (mState & NS_FRAME_PART_OF_IBSPLIT) {
|
||||
|
|
@ -6021,9 +6021,10 @@ FindBlockFrameOrBR(nsIFrame* aFrame, nsDirection aDirection)
|
|||
return result;
|
||||
|
||||
// Check the frame itself
|
||||
// Fall through "special" block frames because their mContent is the content
|
||||
// of the inline frames they were created from. The first/last child of
|
||||
// such frames is the real block frame we're looking for.
|
||||
// Fall through block-in-inline split frames because their mContent is
|
||||
// the content of the inline frames they were created from. The
|
||||
// first/last child of such frames is the real block frame we're
|
||||
// looking for.
|
||||
if ((nsLayoutUtils::GetAsBlock(aFrame) &&
|
||||
!(aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) ||
|
||||
aFrame->GetType() == nsGkAtoms::brFrame) {
|
||||
|
|
@ -7162,10 +7163,11 @@ nsFrame::ConsiderChildOverflow(nsOverflowAreas& aOverflowAreas,
|
|||
}
|
||||
|
||||
/**
|
||||
* This function takes a "special" frame and _if_ that frame is an anonymous
|
||||
* block created by an ib split it returns the block's preceding inline. This
|
||||
* is needed because the split inline's style context is the parent of the
|
||||
* anonymous block's style context.
|
||||
* This function takes a frame that is part of a block-in-inline split,
|
||||
* and _if_ that frame is an anonymous block created by an ib split it
|
||||
* returns the block's preceding inline. This is needed because the
|
||||
* split inline's style context is the parent of the anonymous block's
|
||||
* style context.
|
||||
*
|
||||
* If aFrame is not an anonymous block, null is returned.
|
||||
*/
|
||||
|
|
@ -7174,7 +7176,7 @@ GetIBSplitSiblingForAnonymousBlock(const nsIFrame* aFrame)
|
|||
{
|
||||
NS_PRECONDITION(aFrame, "Must have a non-null frame!");
|
||||
NS_ASSERTION(aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT,
|
||||
"GetIBSplitSibling should not be called on a non-special frame");
|
||||
"GetIBSplitSibling should only be called on ib-split frames");
|
||||
|
||||
nsIAtom* type = aFrame->StyleContext()->GetPseudo();
|
||||
if (type != nsCSSAnonBoxes::mozAnonymousBlock &&
|
||||
|
|
|
|||
|
|
@ -135,9 +135,8 @@ FRAME_STATE_BIT(Generic, 13, NS_FRAME_HAS_VIEW)
|
|||
// If this bit is set, the frame was created from anonymous content.
|
||||
FRAME_STATE_BIT(Generic, 14, NS_FRAME_INDEPENDENT_SELECTION)
|
||||
|
||||
// If this bit is set, the frame is "special" (lame term, I know),
|
||||
// which means that it is part of the mangled frame hierarchy that
|
||||
// results when an inline has been split because of a nested block.
|
||||
// If this bit is set, the frame is part of the mangled frame hierarchy
|
||||
// that results when an inline has been split because of a nested block.
|
||||
// See the comments in nsCSSFrameConstructor::ConstructInline for
|
||||
// more details.
|
||||
FRAME_STATE_BIT(Generic, 15, NS_FRAME_PART_OF_IBSPLIT)
|
||||
|
|
|
|||
|
|
@ -124,8 +124,8 @@ nsInlineFrame::IsSelfEmpty()
|
|||
haveStart = haveRight;
|
||||
haveEnd = haveLeft;
|
||||
}
|
||||
// For special frames, ignore things we know we'll skip in GetSkipSides.
|
||||
// XXXbz should we be doing this for non-special frames too, in a more
|
||||
// For ib-split frames, ignore things we know we'll skip in GetSkipSides.
|
||||
// XXXbz should we be doing this for non-ib-split frames too, in a more
|
||||
// general way?
|
||||
|
||||
// Get the first continuation eagerly, as a performance optimization, to
|
||||
|
|
|
|||
|
|
@ -1069,9 +1069,10 @@ nsLineLayout::ApplyStartMargin(PerFrameData* pfd,
|
|||
|
||||
// Only apply start-margin on the first-in flow for inline frames,
|
||||
// and make sure to not apply it to any inline other than the first
|
||||
// in an ib split. Note that the ib special sibling annotations
|
||||
// only live on the first continuation, but we don't want to apply
|
||||
// the start margin for later continuations anyway.
|
||||
// in an ib split. Note that the ib sibling (block-in-inline
|
||||
// sibling) annotations only live on the first continuation, but we
|
||||
// don't want to apply the start margin for later continuations
|
||||
// anyway.
|
||||
if (pfd->mFrame->GetPrevContinuation() ||
|
||||
pfd->mFrame->FrameIsNonFirstInIBSplit()) {
|
||||
// Zero this out so that when we compute the max-element-width of
|
||||
|
|
|
|||
|
|
@ -274,7 +274,7 @@ public:
|
|||
* requested.)
|
||||
*
|
||||
* This method returns a change hint (see nsChangeHint.h). All change
|
||||
* hints apply to the frame and its later continuations or special
|
||||
* hints apply to the frame and its later continuations or ib-split
|
||||
* siblings. Most (all of those except the "NotHandledForDescendants"
|
||||
* hints) also apply to all descendants. The caller must pass in any
|
||||
* non-inherited hints that resulted from the parent style context's
|
||||
|
|
|
|||
|
|
@ -76,14 +76,14 @@ private:
|
|||
return *r;
|
||||
}
|
||||
// Despite the fact that we're invoked for frames with SVG effects applied,
|
||||
// we can actually get here. All continuations and special siblings of a
|
||||
// we can actually get here. All continuations and IB split siblings of a
|
||||
// frame with SVG effects applied will have the PreEffectsBBoxProperty
|
||||
// property set on them. Therefore, the frames that are passed to us will
|
||||
// always have that property set...well, with one exception. If the frames
|
||||
// for an element with SVG effects applied have been subject to an "IB
|
||||
// split", then the block frame(s) that caused the split will have been
|
||||
// wrapped in anonymous, inline-block, nsBlockFrames of pseudo-type
|
||||
// nsCSSAnonBoxes::mozAnonymousBlock. These "special sibling" anonymous
|
||||
// nsCSSAnonBoxes::mozAnonymousBlock. These "IB split sibling" anonymous
|
||||
// blocks will have the PreEffectsBBoxProperty property set on them, but
|
||||
// they will never be passed to us. Instead, we'll be passed the block
|
||||
// children that they wrap, which don't have the PreEffectsBBoxProperty
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче