зеркало из https://github.com/mozilla/gecko-dev.git
1706 строки
57 KiB
C++
1706 строки
57 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "License"); you may not use this file except in
|
|
* compliance with the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS"
|
|
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
|
|
* the License for the specific language governing rights and limitations
|
|
* under the License.
|
|
*
|
|
* The Original Code is Mozilla Communicator client code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape Communications
|
|
* Corporation. Portions created by Netscape are Copyright (C) 1998
|
|
* Netscape Communications Corporation. All Rights Reserved.
|
|
*/
|
|
#include "nsBlockFrame.h"
|
|
#include "nsFrameList.h"
|
|
#include "nsBlockReflowContext.h"
|
|
#include "nsLineLayout.h"
|
|
#include "nsInlineReflow.h"
|
|
#include "nsHTMLAtoms.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIStyleContext.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsIPresContext.h"
|
|
#include "nsFrameReflowState.h"
|
|
|
|
#ifdef NS_DEBUG
|
|
#undef NOISY_ANON_BLOCK
|
|
#else
|
|
#undef NOISY_ANON_BLOCK
|
|
#endif
|
|
|
|
// XXX TODO:
|
|
// append/insert/remove floater testing
|
|
|
|
#define INLINE_FRAME_CID \
|
|
{ 0xa6cf90e0, 0x15b3, 0x11d2,{0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}
|
|
|
|
static NS_DEFINE_IID(kInlineFrameCID, INLINE_FRAME_CID);
|
|
|
|
// Theory of operation:
|
|
// XXX write this
|
|
|
|
#if XXX
|
|
// An additional bit in the reserved portion of nsIFrame's frame-state
|
|
// that we use. When set the bit indicates that this inline frame has
|
|
// an anonymous block that it is using to reflow block child frames.
|
|
#define HAVE_ANONYMOUS_BLOCK 0x10000
|
|
#endif
|
|
|
|
#define nsInlineFrameSuper nsHTMLContainerFrame
|
|
|
|
class nsInlineFrame : public nsInlineFrameSuper
|
|
{
|
|
public:
|
|
friend nsresult NS_NewInlineFrame(nsIFrame*& aNewFrame);
|
|
|
|
// nsISupports overrides
|
|
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
|
|
|
|
// nsIFrame overrides
|
|
NS_IMETHOD SetInitialChildList(nsIPresContext& aPresContext,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aChildList);
|
|
NS_IMETHOD AppendFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aFrameList);
|
|
NS_IMETHOD InsertFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList);
|
|
NS_IMETHOD RemoveFrame(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame);
|
|
NS_IMETHOD DeleteFrame(nsIPresContext& aPresContext);
|
|
NS_IMETHOD CreateContinuingFrame(nsIPresContext& aCX,
|
|
nsIFrame* aParent,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aContinuingFrame);
|
|
NS_IMETHOD GetFrameName(nsString& aResult) const;
|
|
|
|
// nsIHTMLReflow overrides
|
|
NS_IMETHOD Reflow(nsIPresContext& aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus);
|
|
#if XXX_fix_me
|
|
NS_IMETHOD FindTextRuns(nsLineLayout& aLineLayout);
|
|
NS_IMETHOD AdjustFrameSize(nscoord aExtraSpace, nscoord& aUsedSpace);
|
|
NS_IMETHOD TrimTrailingWhiteSpace(nsIPresContext& aPresContext,
|
|
nsIRenderingContext& aRC,
|
|
nscoord& aDeltaWidth);
|
|
#endif
|
|
|
|
protected:
|
|
// Reflow state used during our reflow methods
|
|
struct ReflowState : public nsFrameReflowState {
|
|
ReflowState(nsIPresContext& aPresContext,
|
|
const nsHTMLReflowState& aReflowState,
|
|
const nsHTMLReflowMetrics& aMetrics,
|
|
nsInlineFrame* aNextInFlow)
|
|
: nsFrameReflowState(aPresContext, aReflowState, aMetrics),
|
|
prevFrame(nsnull),
|
|
nextInFlow(aNextInFlow)
|
|
{
|
|
}
|
|
|
|
nsInlineReflow* inlineReflow;
|
|
nsIFrame* prevFrame;
|
|
nsInlineFrame* nextInFlow;
|
|
};
|
|
|
|
// A helper class that knows how to take a list of frames and chop
|
|
// it up into 3 sections.
|
|
struct SectionData {
|
|
SectionData(nsIFrame* aFrameList);
|
|
|
|
PRBool SplitFrameList(nsFrameList& aSection1,
|
|
nsFrameList& aSection2,
|
|
nsFrameList& aSection3);
|
|
|
|
PRBool HasABlock() const {
|
|
return nsnull != firstBlock;
|
|
}
|
|
|
|
nsIFrame* firstBlock;
|
|
nsIFrame* prevFirstBlock;
|
|
nsIFrame* lastBlock;
|
|
nsIFrame* firstFrame;
|
|
nsIFrame* lastFrame;
|
|
};
|
|
|
|
nsInlineFrame();
|
|
~nsInlineFrame();
|
|
|
|
virtual PRIntn GetSkipSides() const;
|
|
|
|
PRBool HaveAnonymousBlock() const {
|
|
#ifdef HAVE_ANONYMOUS_BLOCK
|
|
return 0 != (mState & HAVE_ANONYMOUS_BLOCK);
|
|
#else
|
|
return mFrames.NotEmpty()
|
|
? nsLineLayout::TreatFrameAsBlock(mFrames.FirstChild())
|
|
: PR_FALSE;
|
|
#endif
|
|
}
|
|
|
|
static PRBool ParentIsInlineFrame(nsIFrame* aFrame, nsIFrame** aParent) {
|
|
void* tmp;
|
|
nsIFrame* parent;
|
|
aFrame->GetParent(&parent);
|
|
*aParent = parent;
|
|
if (NS_SUCCEEDED(parent->QueryInterface(kInlineFrameCID, &tmp))) {
|
|
return PR_TRUE;
|
|
}
|
|
return PR_FALSE;
|
|
}
|
|
|
|
nsresult MoveOutOfFlow(nsIPresContext& aPresContext, nsIFrame* aFrameList);
|
|
|
|
nsAnonymousBlockFrame* FindPrevAnonymousBlock(nsInlineFrame** aBlockParent);
|
|
|
|
nsAnonymousBlockFrame* FindAnonymousBlock(nsInlineFrame** aBlockParent);
|
|
|
|
nsresult CreateAnonymousBlock(nsIPresContext& aPresContext,
|
|
nsIFrame* aFrameList,
|
|
nsIFrame** aResult);
|
|
|
|
nsresult AppendFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIFrame* aFrameList,
|
|
PRBool aGenerateReflowCommands);
|
|
|
|
nsresult InsertBlockFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList);
|
|
|
|
nsresult InsertInlineFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList);
|
|
|
|
nsresult ReflowInlineFrames(ReflowState& rs,
|
|
nsHTMLReflowMetrics& aMetrics,
|
|
nsReflowStatus& aStatus);
|
|
|
|
nsresult ReflowInlineFrame(ReflowState& rs,
|
|
nsIFrame* aFrame,
|
|
nsReflowStatus& aStatus);
|
|
|
|
nsIFrame* PullInlineFrame(ReflowState& rs, PRBool* aIsComplete);
|
|
|
|
nsIFrame* PullAnyFrame(ReflowState& rs);
|
|
|
|
void PushFrames(nsIFrame* aFromChild, nsIFrame* aPrevSibling);
|
|
|
|
void DrainOverflow();
|
|
|
|
nsresult ReflowBlockFrame(ReflowState& rs,
|
|
nsHTMLReflowMetrics& aMetrics,
|
|
nsReflowStatus& aStatus);
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// SectionData implementation
|
|
|
|
nsInlineFrame::SectionData::SectionData(nsIFrame* aFrameList)
|
|
{
|
|
firstBlock = nsnull;
|
|
prevFirstBlock = nsnull;
|
|
lastBlock = nsnull;
|
|
lastFrame = nsnull;
|
|
|
|
// Find the first and last block (if any!). When we exit the loop
|
|
// lastFrame will be the last frame in aList.
|
|
nsIFrame* frame = aFrameList;
|
|
firstFrame = aFrameList;
|
|
while (nsnull != frame) {
|
|
if (nsLineLayout::TreatFrameAsBlock(frame)) {
|
|
if (nsnull == firstBlock) {
|
|
prevFirstBlock = lastFrame;
|
|
firstBlock = frame;
|
|
lastBlock = frame;
|
|
}
|
|
else {
|
|
lastBlock = frame;
|
|
}
|
|
}
|
|
lastFrame = frame;
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
}
|
|
|
|
PRBool
|
|
nsInlineFrame::SectionData::SplitFrameList(nsFrameList& aSection1,
|
|
nsFrameList& aSection2,
|
|
nsFrameList& aSection3)
|
|
{
|
|
if (nsnull == firstBlock) {
|
|
// There are no blocks
|
|
return PR_FALSE;
|
|
}
|
|
|
|
// We have at least one block
|
|
if (nsnull != prevFirstBlock) {
|
|
// The first block is not the first frame in aList. Setup section1.
|
|
prevFirstBlock->SetNextSibling(nsnull);
|
|
aSection1.SetFrames(firstFrame);
|
|
}
|
|
aSection2.SetFrames(firstBlock);
|
|
|
|
if (lastFrame != lastBlock) {
|
|
// There are inline frames that follow the last block. Setup section3.
|
|
nsIFrame* remainder;
|
|
lastBlock->GetNextSibling(&remainder);
|
|
lastBlock->SetNextSibling(nsnull);
|
|
aSection3.SetFrames(remainder);
|
|
}
|
|
|
|
return PR_TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Basic nsInlineFrame methods
|
|
|
|
nsresult
|
|
NS_NewInlineFrame(nsIFrame*& aNewFrame)
|
|
{
|
|
nsInlineFrame* it = new nsInlineFrame;
|
|
if (nsnull == it) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
aNewFrame = it;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsInlineFrame::nsInlineFrame()
|
|
{
|
|
}
|
|
|
|
nsInlineFrame::~nsInlineFrame()
|
|
{
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::QueryInterface(const nsIID& aIID, void** aInstancePtr)
|
|
{
|
|
if (nsnull == aInstancePtr) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
if (aIID.Equals(kInlineFrameCID)) {
|
|
nsInlineFrame* tmp = this;
|
|
*aInstancePtr = (void*) tmp;
|
|
return NS_OK;
|
|
}
|
|
return nsInlineFrameSuper::QueryInterface(aIID, aInstancePtr);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::GetFrameName(nsString& aResult) const
|
|
{
|
|
return MakeFrameName("Inline", aResult);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::DeleteFrame(nsIPresContext& aPresContext)
|
|
{
|
|
mFrames.DeleteFrames(aPresContext);
|
|
return nsInlineFrameSuper::DeleteFrame(aPresContext);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// nsInlineFrame child management
|
|
|
|
nsresult
|
|
nsInlineFrame::MoveOutOfFlow(nsIPresContext& aPresContext,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
nsIFrame* prevFrame = nsnull;
|
|
nsIFrame* frame = aFrameList;
|
|
while (nsnull != frame) {
|
|
const nsStyleDisplay* dpy;
|
|
frame->GetStyleData(eStyleStruct_Display, (const nsStyleStruct*&) dpy);
|
|
const nsStylePosition* pos;
|
|
frame->GetStyleData(eStyleStruct_Position, (const nsStyleStruct*&) pos);
|
|
|
|
// See if we need to move the frame outside of the flow, and insert a
|
|
// placeholder frame in its place
|
|
nsIFrame* placeholder;
|
|
if (MoveFrameOutOfFlow(aPresContext, frame, dpy, pos, placeholder)) {
|
|
if (nsnull != prevFrame) {
|
|
prevFrame->SetNextSibling(placeholder);
|
|
}
|
|
frame = placeholder;
|
|
}
|
|
prevFrame = frame;
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
// Find the first inline frame, looking backwards starting at "this",
|
|
// that contains an anonymous block. Return nsnull if an anonymous
|
|
// block is not found.
|
|
nsAnonymousBlockFrame*
|
|
nsInlineFrame::FindPrevAnonymousBlock(nsInlineFrame** aBlockParent)
|
|
{
|
|
nsInlineFrame* prevInFlow = this;
|
|
while (nsnull != prevInFlow) {
|
|
// Scan the prev-in-flows frame list, looking for an anonymous
|
|
// block frame.
|
|
nsIFrame* frame = prevInFlow->mFrames.FirstChild();
|
|
while (nsnull != frame) {
|
|
if (nsLineLayout::TreatFrameAsBlock(frame)) {
|
|
*aBlockParent = prevInFlow;
|
|
return (nsAnonymousBlockFrame*) frame;
|
|
}
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
prevInFlow = (nsInlineFrame*) prevInFlow->mPrevInFlow;
|
|
}
|
|
return nsnull;
|
|
}
|
|
|
|
// Find the first inline frame, looking forwards starting at "this",
|
|
// that contains an anonymous block. Return nsnull if an anonymous
|
|
// block is not found.
|
|
nsAnonymousBlockFrame*
|
|
nsInlineFrame::FindAnonymousBlock(nsInlineFrame** aBlockParent)
|
|
{
|
|
nsInlineFrame* nextInFlow = this;
|
|
while (nsnull != nextInFlow) {
|
|
// Scan the prev-in-flows frame list, looking for an anonymous
|
|
// block frame.
|
|
nsIFrame* frame = nextInFlow->mFrames.FirstChild();
|
|
while (nsnull != frame) {
|
|
if (nsLineLayout::TreatFrameAsBlock(frame)) {
|
|
*aBlockParent = nextInFlow;
|
|
return (nsAnonymousBlockFrame*) frame;
|
|
}
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
nextInFlow = (nsInlineFrame*) nextInFlow->mNextInFlow;
|
|
}
|
|
return nsnull;
|
|
}
|
|
|
|
nsresult
|
|
nsInlineFrame::CreateAnonymousBlock(nsIPresContext& aPresContext,
|
|
nsIFrame* aInitialFrames,
|
|
nsIFrame** aResult)
|
|
{
|
|
nsIFrame* bf;
|
|
nsresult rv = NS_NewAnonymousBlockFrame(bf);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsCOMPtr<nsIStyleContext> newSC;
|
|
aPresContext.ResolvePseudoStyleContextFor(mContent,
|
|
nsHTMLAtoms::mozAnonymousBlock,
|
|
mStyleContext,
|
|
getter_AddRefs(newSC));
|
|
rv = bf->Init(aPresContext, mContent, this, newSC);
|
|
if (NS_FAILED(rv)) {
|
|
bf->DeleteFrame(aPresContext);
|
|
delete bf;
|
|
}
|
|
else {
|
|
// Set parent for the frames now that the anonymous block has
|
|
// been created.
|
|
nsIFrame* frame = aInitialFrames;
|
|
while (nsnull != frame) {
|
|
frame->SetParent(bf);
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
rv = bf->SetInitialChildList(aPresContext, nsnull, aInitialFrames);
|
|
}
|
|
*aResult = bf;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::SetInitialChildList(nsIPresContext& aPresContext,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
if (nsnull != aListName) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
if (nsnull == aFrameList) {
|
|
return NS_OK;
|
|
}
|
|
nsIPresShell* shell;
|
|
shell = aPresContext.GetShell();
|
|
nsresult rv = AppendFrames(aPresContext, *shell, aFrameList, PR_FALSE);
|
|
NS_RELEASE(shell);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::AppendFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
if (nsnull != aListName) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (nsnull == aFrameList) {
|
|
return NS_OK;
|
|
}
|
|
return AppendFrames(aPresContext, aPresShell, aFrameList, PR_TRUE);
|
|
}
|
|
|
|
nsresult
|
|
nsInlineFrame::AppendFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIFrame* aFrameList,
|
|
PRBool aGenerateReflowCommands)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
rv = MoveOutOfFlow(aPresContext, aFrameList);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
SectionData sd(aFrameList);
|
|
|
|
if (sd.HasABlock()) {
|
|
nsFrameList section1, section2, section3;
|
|
sd.SplitFrameList(section1, section2, section3);
|
|
|
|
// There is at least one block in the new frames. See if there is
|
|
// an anonymous block frame in a prev-in-flow of this frame.
|
|
nsInlineFrame* prevInline;
|
|
nsAnonymousBlockFrame* anonymousBlock;
|
|
anonymousBlock = FindPrevAnonymousBlock(&prevInline);
|
|
if (nsnull != anonymousBlock) {
|
|
// One of the invariants of nsInlineFrame is that there will be
|
|
// at most one anonymous block frame that reflows the
|
|
// nsInlineFrame's block children (not counting any
|
|
// continuations of the anonymous block frame).
|
|
//
|
|
// We maintain that invariant by noticing when a new block frame
|
|
// enters the list of children and ensuring that all of the
|
|
// frames from the first block to the last block are contained
|
|
// by the anonymous block (or one of its continuations). This
|
|
// can cause some inline frames between here and the inline that
|
|
// contains anonymousBlock to have their children stuffed into
|
|
// the anonymous block.
|
|
|
|
// Build a list of the frames between the anonymous block and
|
|
// this frame, stealing children from our continuation frames as
|
|
// necessary.
|
|
nsIFrame* inlineSiblings;
|
|
anonymousBlock->GetNextSibling(&inlineSiblings);
|
|
nsFrameList newBlockFrames;
|
|
if (nsnull != inlineSiblings) {
|
|
newBlockFrames.AppendFrames(anonymousBlock, inlineSiblings);
|
|
}
|
|
nsInlineFrame* tmp = (nsInlineFrame*) prevInline->mNextInFlow;
|
|
while ((nsnull != tmp) && (this != tmp)) {
|
|
newBlockFrames.AppendFrames(anonymousBlock, tmp->mFrames);
|
|
tmp = (nsInlineFrame*) tmp->mNextInFlow;
|
|
}
|
|
|
|
// Now tack on all of this frame's child frames (unless this
|
|
// frame is the frame that contains the anonymous block)
|
|
if (this != prevInline) {
|
|
newBlockFrames.AppendFrames(anonymousBlock, mFrames);
|
|
}
|
|
|
|
// And then append section1 and section2 frames.
|
|
if (section1.NotEmpty()) {
|
|
newBlockFrames.AppendFrames(anonymousBlock, section1);
|
|
}
|
|
newBlockFrames.AppendFrames(anonymousBlock, section2);
|
|
|
|
// Finally, if there are any frames in section3 then they are
|
|
// appended after the anonymous block. These frames will be
|
|
// reflowed when they are pushed from the prevInline frame to a
|
|
// next-in-flow after the anonymousBlock frame is reflowed.
|
|
anonymousBlock->SetNextSibling(section3.FirstChild());
|
|
|
|
// Now we can append the frames to the anonymous block and it
|
|
// can generate a reflow command.
|
|
rv = anonymousBlock->AppendFrames2(aPresContext, aPresShell, nsnull,
|
|
newBlockFrames.FirstChild());
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("AppendFrames: case 1\n");
|
|
#endif
|
|
}
|
|
else {
|
|
// There is no prior block frames that are the children of this
|
|
// inline. Therefore, section 1 is appended to our frame list
|
|
// and we wrap up the frames in section 2 with a new anonymous
|
|
// block and the frames in section 3 get appended to the frame
|
|
// list after the anonymous frame (so that they can be pushed to
|
|
// a next-in-flow after this finishes reflowing its anonymous
|
|
// block).
|
|
nsIFrame* anonymousBlock;
|
|
rv = CreateAnonymousBlock(aPresContext, section2.FirstChild(),
|
|
&anonymousBlock);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
if (section1.NotEmpty()) {
|
|
mFrames.AppendFrames(nsnull, section1);
|
|
}
|
|
mFrames.AppendFrame(nsnull, anonymousBlock);
|
|
if (section3.NotEmpty()) {
|
|
mFrames.AppendFrames(nsnull, section3);
|
|
}
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("AppendFrames: case 2\n");
|
|
#endif
|
|
|
|
if (aGenerateReflowCommands) {
|
|
// generate a reflow command for "this"
|
|
nsIReflowCommand* reflowCmd = nsnull;
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, this,
|
|
nsIReflowCommand::ReflowDirty);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
aPresShell.AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// The new frames contain no block frames
|
|
mFrames.AppendFrames(this, aFrameList);
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("AppendFrames: case 3\n");
|
|
#endif
|
|
|
|
if (aGenerateReflowCommands) {
|
|
// generate a reflow command for "this"
|
|
nsIReflowCommand* reflowCmd = nsnull;
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, this,
|
|
nsIReflowCommand::ReflowDirty);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
aPresShell.AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::InsertFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
if (nsnull != aListName) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
if (nsnull == aFrameList) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult rv = NS_OK;
|
|
rv = MoveOutOfFlow(aPresContext, aFrameList);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
SectionData sd(aFrameList);
|
|
if (sd.HasABlock()) {
|
|
// Break insertion up into 3 pieces
|
|
nsFrameList section1, section2, section3;
|
|
sd.SplitFrameList(section1, section2, section3);
|
|
|
|
nsIFrame* prevFrame = aPrevFrame;
|
|
|
|
// First insert the inlines in section1 after prevFrame
|
|
if (section1.NotEmpty()) {
|
|
nsIFrame* newPrevFrame = section1.LastChild();
|
|
rv = InsertInlineFrames(aPresContext, aPresShell, prevFrame,
|
|
section1.FirstChild());
|
|
prevFrame = newPrevFrame;
|
|
}
|
|
|
|
// Next insert the frames in section2 after prevFrame
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsIFrame* newPrevFrame = section2.LastChild();
|
|
rv = InsertBlockFrames(aPresContext, aPresShell, prevFrame,
|
|
section2.FirstChild());
|
|
prevFrame = newPrevFrame;
|
|
}
|
|
|
|
// Finally, insert the frames in section3 after prevFrame
|
|
if (NS_SUCCEEDED(rv) && section3.NotEmpty()) {
|
|
rv = InsertInlineFrames(aPresContext, aPresShell, prevFrame,
|
|
section3.FirstChild());
|
|
}
|
|
}
|
|
else {
|
|
// Use simpler path when the insertion is only inline frames
|
|
rv = InsertInlineFrames(aPresContext, aPresShell, aPrevFrame, aFrameList);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsInlineFrame::InsertBlockFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
PRBool generateReflowCommand = PR_FALSE;
|
|
nsIFrame* target = nsnull;
|
|
|
|
if (nsnull == aPrevFrame) {
|
|
// The block is being inserted at the head of all the child
|
|
// frames.
|
|
nsInlineFrame* flow;
|
|
nsAnonymousBlockFrame* anonymousBlock = FindAnonymousBlock(&flow);
|
|
if (nsnull == anonymousBlock) {
|
|
// There are no anonymous blocks so create one and place the
|
|
// frames into it.
|
|
nsIFrame* anonymousBlock;
|
|
rv = CreateAnonymousBlock(aPresContext, aFrameList, &anonymousBlock);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
mFrames.InsertFrames(this, nsnull, anonymousBlock);
|
|
target = this;
|
|
generateReflowCommand = PR_TRUE;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertBlockFrames: case 1\n");
|
|
#endif
|
|
}
|
|
else {
|
|
// Take all of the frames before the anonymous block, plus the
|
|
// frames in aFrameList and insert them into the anonymous
|
|
// block.
|
|
nsFrameList frames;
|
|
frames.AppendFrames(anonymousBlock, aFrameList);
|
|
nsInlineFrame* start = this;
|
|
while (start != flow) {
|
|
frames.AppendFrames(anonymousBlock, start->mFrames);
|
|
start->GetNextInFlow((nsIFrame*&) start);
|
|
}
|
|
anonymousBlock->InsertFrames2(aPresContext, aPresShell, nsnull,
|
|
nsnull, frames.FirstChild());
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertBlockFrames: case 2\n");
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
// First see if the insertion is inside the anonymous block
|
|
nsIFrame* prevFrameParent;
|
|
aPrevFrame->GetParent(&prevFrameParent);
|
|
if (nsLineLayout::TreatFrameAsBlock(prevFrameParent)) {
|
|
// The previous frame's parent is an anonymous block. This means
|
|
// that the new block frames can be safely inserted there.
|
|
nsIFrame* frame = aFrameList;
|
|
while (nsnull != frame) {
|
|
frame->SetParent(prevFrameParent);
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
nsAnonymousBlockFrame* anonymousBlock;
|
|
anonymousBlock = (nsAnonymousBlockFrame*) prevFrameParent;
|
|
anonymousBlock->InsertFrames2(aPresContext, aPresShell, nsnull,
|
|
aPrevFrame, aFrameList);
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertBlockFrames: case 3\n");
|
|
#endif
|
|
}
|
|
else {
|
|
// The previous frame's parent is an inline frame. First see if
|
|
// there is an anonymous block before the insertion point.
|
|
nsInlineFrame* flow = (nsInlineFrame*) prevFrameParent;
|
|
nsAnonymousBlockFrame* anonymousBlock;
|
|
anonymousBlock = flow->FindPrevAnonymousBlock(&flow);
|
|
if (nsnull != anonymousBlock) {
|
|
// We found an anonymous block before the insertion
|
|
// point. Take all of the inline frames between the anonymous
|
|
// block and prevFrameParent and strip them away from the
|
|
// inline frames that contain them.
|
|
nsFrameList frames;
|
|
nsInlineFrame* start;
|
|
flow->GetNextInFlow((nsIFrame*&) start); // start after anon block
|
|
while (start != prevFrameParent) {
|
|
frames.AppendFrames(anonymousBlock, start->mFrames);
|
|
start->GetNextInFlow((nsIFrame*&) start);
|
|
}
|
|
|
|
// Now append the frames just before and including aPrevFrame
|
|
// to "frames".
|
|
flow = (nsInlineFrame*) prevFrameParent;
|
|
nsIFrame* remainder;
|
|
flow->mFrames.Split(aPrevFrame, &remainder);
|
|
frames.AppendFrames(anonymousBlock, flow->mFrames);
|
|
flow->mFrames.SetFrames(remainder);
|
|
generateReflowCommand = PR_TRUE;
|
|
target = flow;
|
|
|
|
// Finally, append the block frames to "frames" and then
|
|
// append the list of frames to the anonymous block.
|
|
frames.AppendFrames(anonymousBlock, aFrameList);
|
|
anonymousBlock->AppendFrames2(aPresContext, aPresShell, nsnull,
|
|
frames.FirstChild());
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertBlockFrames: case 4\n");
|
|
#endif
|
|
}
|
|
else {
|
|
// There is no anymous block before the insertion point. See
|
|
// if there is one after the insertion point.
|
|
flow = (nsInlineFrame*) prevFrameParent;
|
|
anonymousBlock = flow->FindAnonymousBlock(&flow);
|
|
if (nsnull != anonymousBlock) {
|
|
// We found an anonymous block after the insertion
|
|
// point. Seed the list of frames to put into the anonymous
|
|
// block with the block frames being inserted.
|
|
nsFrameList frames;
|
|
frames.AppendFrames(anonymousBlock, aFrameList);
|
|
nsInlineFrame* start = (nsInlineFrame*) prevFrameParent;
|
|
|
|
// Take the frames after aPrevFrame and place them at the
|
|
// end of the frames list.
|
|
nsIFrame* remainder;
|
|
start->mFrames.Split(aPrevFrame, &remainder);
|
|
if (nsnull != remainder) {
|
|
frames.AppendFrames(anonymousBlock, remainder);
|
|
}
|
|
generateReflowCommand = PR_TRUE;
|
|
target = start;
|
|
|
|
// Gather up all of the inline frames from all of the flow
|
|
// between the insertion point and the anonymous block.
|
|
start->GetNextInFlow((nsIFrame*&) start);
|
|
while (start != flow) {
|
|
frames.AppendFrames(anonymousBlock, start->mFrames);
|
|
start->GetNextInFlow((nsIFrame*&) start);
|
|
}
|
|
|
|
// Now update the anonymous block
|
|
anonymousBlock->InsertFrames2(aPresContext, aPresShell, nsnull,
|
|
nsnull, frames.FirstChild());
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertBlockFrames: case 5\n");
|
|
#endif
|
|
}
|
|
else {
|
|
// There are no anonymous blocks so create one and place the
|
|
// frames into it.
|
|
nsIFrame* anonymousBlock;
|
|
rv = CreateAnonymousBlock(aPresContext, aFrameList, &anonymousBlock);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
// Insert the frame into the correct parent (it will not be
|
|
// this frame when aPrevFrame's parent != this)
|
|
flow = (nsInlineFrame*) prevFrameParent;
|
|
flow->mFrames.InsertFrames(flow, aPrevFrame, anonymousBlock);
|
|
generateReflowCommand = PR_TRUE;
|
|
target = flow;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertBlockFrames: case 6\n");
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (generateReflowCommand) {
|
|
// generate a reflow command for "this"
|
|
nsIReflowCommand* reflowCmd = nsnull;
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, target,
|
|
nsIReflowCommand::ReflowDirty);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
aPresShell.AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsInlineFrame::InsertInlineFrames(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
PRBool generateReflowCommand = PR_FALSE;
|
|
nsIFrame* target = nsnull;
|
|
|
|
if (nsnull == aPrevFrame) {
|
|
// Insert the frames at the front of our list. Since the frames
|
|
// are all inline frames we just place them there, even if our
|
|
// current first frame is the anonymous block frame. The reflow
|
|
// logic will properly push the anonymous block frame to a
|
|
// next-in-flow.
|
|
mFrames.InsertFrames(this, nsnull, aFrameList);
|
|
generateReflowCommand = PR_TRUE;
|
|
target = this;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertInlineFrames: case 1\n");
|
|
#endif
|
|
}
|
|
else {
|
|
nsIFrame* prevFrameParent;
|
|
aPrevFrame->GetParent(&prevFrameParent);
|
|
if (nsLineLayout::TreatFrameAsBlock(prevFrameParent)) {
|
|
nsAnonymousBlockFrame* anonymousBlock;
|
|
anonymousBlock = (nsAnonymousBlockFrame*) prevFrameParent;
|
|
|
|
// The previous frame's parent is an anonymous block (otherwise
|
|
// its parent would be this frame). We must not place the inline
|
|
// frames into the anonymous block if they should be in
|
|
// section3.
|
|
nsIFrame* nextSibling;
|
|
aPrevFrame->GetNextSibling(&nextSibling);
|
|
nsIFrame* anonymousBlockNextInFlow;
|
|
prevFrameParent->GetNextInFlow(anonymousBlockNextInFlow);
|
|
if ((nsnull != nextSibling) || (nsnull != anonymousBlockNextInFlow)) {
|
|
// Easy case: there are more frames following aPrevFrame which
|
|
// means that this insertion lies in the anonymous block.
|
|
nsIFrame* frame = aFrameList;
|
|
while (nsnull != frame) {
|
|
frame->SetParent(anonymousBlock);
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
anonymousBlock->InsertFrames2(aPresContext, aPresShell, nsnull,
|
|
aPrevFrame, aFrameList);
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertInlineFrames: case 2\n");
|
|
#endif
|
|
}
|
|
else {
|
|
// aPrevFrame is the last frame that should be in the
|
|
// anonymous block.
|
|
nsInlineFrame* anonymousBlockParent;
|
|
anonymousBlock->GetParent((nsIFrame**)&anonymousBlockParent);
|
|
|
|
// Place the inline frames after the anonymous block
|
|
nsIFrame* frame = aFrameList;
|
|
while (nsnull != frame) {
|
|
frame->SetParent(anonymousBlockParent);
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
anonymousBlockParent->mFrames.InsertFrames(nsnull, anonymousBlock,
|
|
aFrameList);
|
|
generateReflowCommand = PR_TRUE;
|
|
target = anonymousBlockParent;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertInlineFrames: case 3\n");
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
// The previous frame's parent is an inline frame. Therefore
|
|
// this is either a section1 or section3 insertion. Insert the
|
|
// frames in the proper flow block (which will be aPrevFrame's
|
|
// parent which is currently stored in anonymousBlock)
|
|
nsInlineFrame* flow = (nsInlineFrame*) prevFrameParent;
|
|
flow->mFrames.InsertFrames(flow, aPrevFrame, aFrameList);
|
|
generateReflowCommand = PR_TRUE;
|
|
target = flow;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("InsertInlineFrames: case 4\n");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (generateReflowCommand) {
|
|
// generate a reflow command for "this"
|
|
nsIReflowCommand* reflowCmd = nsnull;
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, target,
|
|
nsIReflowCommand::ReflowDirty);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
aPresShell.AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::RemoveFrame(nsIPresContext& aPresContext,
|
|
nsIPresShell& aPresShell,
|
|
nsIAtom* aListName,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
if (nsnull != aListName) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
nsresult rv = NS_OK;
|
|
PRBool generateReflowCommand = PR_FALSE;
|
|
nsIFrame* target = nsnull;
|
|
|
|
nsIFrame* oldFrameParent;
|
|
if (ParentIsInlineFrame(aOldFrame, &oldFrameParent)) {
|
|
// When the parent is an inline frame we have a simple task - just
|
|
// remove the frame from our list and generate a reflow.
|
|
mFrames.DeleteFrame(aPresContext, aOldFrame);
|
|
generateReflowCommand = PR_TRUE;
|
|
target = this;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("RemoveFrame: case 1\n");
|
|
#endif
|
|
}
|
|
else {
|
|
nsIFrame* nextInFlow;
|
|
nsIFrame* prevInFlow;
|
|
|
|
// The parent is not an inline frame which means it is an
|
|
// anonymous block frame.
|
|
nsAnonymousBlockFrame* anonymousBlock =
|
|
(nsAnonymousBlockFrame*) oldFrameParent;
|
|
|
|
// It is possible that we are about to remove the last child of
|
|
// the anonymous block. In this case we remove the anonymous block.
|
|
nsIFrame* kids;
|
|
anonymousBlock->FirstChild(nsnull, &kids);
|
|
nsFrameList blockKids(kids);
|
|
if (1 == blockKids.GetLength()) {
|
|
// Remove the anonymous block
|
|
mFrames.DeleteFrame(aPresContext, anonymousBlock);
|
|
generateReflowCommand = PR_TRUE;
|
|
target = this;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("RemoveFrame: case 2\n");
|
|
#endif
|
|
}
|
|
else {
|
|
// If the frame being removed is a block frame then we may need to
|
|
// do something fancy.
|
|
if (nsLineLayout::TreatFrameAsBlock(aOldFrame)) {
|
|
// It is possible that we are removing the first block in the
|
|
// anonymous block or the last block. See if its so.
|
|
anonymousBlock->GetPrevInFlow(prevInFlow);
|
|
nsIFrame* prevSib;
|
|
if ((nsnull != prevInFlow) ||
|
|
(nsnull != (prevSib = blockKids.GetPrevSiblingFor(aOldFrame)))) {
|
|
// There is a block in the anonymous block prior to the
|
|
// block that we are removing. See if we are removing the
|
|
// last block in the anonymous block.
|
|
anonymousBlock->GetNextInFlow(nextInFlow);
|
|
nsIFrame* nextSib;
|
|
aOldFrame->GetNextSibling(&nextSib);
|
|
if ((nsnull != nextInFlow) || (nsnull != nextSib)) {
|
|
// There is a block in the anonymous block after the block
|
|
// that we are removing. This means that we can let the
|
|
// anonymous block remove the frame.
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("RemoveFrame: case 3\n");
|
|
#endif
|
|
anonymousBlock->RemoveFrame2(aPresContext, aPresShell, aListName,
|
|
aOldFrame);
|
|
}
|
|
else {
|
|
// We are removing the last block. We must steal all of
|
|
// the inline frames that preceed the block being removed
|
|
// (up to the closest prior block) so that they can be
|
|
// moved outside the anonymous block and into an inline
|
|
// frame.
|
|
|
|
// First get the last frame out of the picture; delete any
|
|
// continuations it might have.
|
|
nsInlineFrame* anonymousBlockParent;
|
|
anonymousBlock->GetParent((nsIFrame**) &anonymousBlockParent);
|
|
nsAnonymousBlockFrame* ab = anonymousBlock;
|
|
anonymousBlock->RemoveFramesFrom(aOldFrame);
|
|
aOldFrame->DeleteFrame(aPresContext);
|
|
while (nsnull != nextInFlow) {
|
|
nsIFrame* nextParent;
|
|
nextInFlow->GetParent(&nextParent);
|
|
if (nextParent != ab) {
|
|
ab = (nsAnonymousBlockFrame*) nextParent;
|
|
}
|
|
ab->RemoveFirstFrame();
|
|
nsIFrame* nextNextInFlow;
|
|
nextInFlow->GetNextInFlow(nextNextInFlow);
|
|
nextInFlow->DeleteFrame(aPresContext);
|
|
nextInFlow = nextNextInFlow;
|
|
}
|
|
|
|
// Any inline frames that are between the new last-block
|
|
// inside the anonymous block and the block we just
|
|
// removed need to be taken out of the anonymous block.
|
|
nsFrameList inlines;
|
|
while (nsnull != anonymousBlock) {
|
|
// Find the first inline before the last block
|
|
nsIFrame* kids;
|
|
anonymousBlock->FirstChild(nsnull, &kids);
|
|
if (nsnull != kids) {
|
|
SectionData sd(kids);
|
|
if (sd.HasABlock()) {
|
|
kids = sd.lastBlock;
|
|
kids->GetNextSibling(&kids);
|
|
if (nsnull != kids) {
|
|
// Take the frames that follow the last block
|
|
// (which are inline frames) and remove them from
|
|
// the anonymous block. Insert them into the
|
|
// inlines frame-list.
|
|
anonymousBlock->RemoveFramesFrom(kids);
|
|
inlines.InsertFrames(nsnull, nsnull, kids);
|
|
}
|
|
}
|
|
else {
|
|
// All of the frames are inline frames -- take them
|
|
// all away.
|
|
anonymousBlock->RemoveFramesFrom(kids);
|
|
inlines.InsertFrames(nsnull, nsnull, kids);
|
|
}
|
|
}
|
|
anonymousBlock->GetPrevInFlow((nsIFrame*&) anonymousBlock);
|
|
}
|
|
|
|
// Now we have all of the inline frames that need to be
|
|
// placed into an inline parent instead of the anonymous
|
|
// block parent.
|
|
if (inlines.NotEmpty()) {
|
|
// Place the inline frames after the anonymous block
|
|
// frame in the child list of the anonymousBlockParent.
|
|
anonymousBlockParent->mFrames.AppendFrames(anonymousBlockParent,
|
|
inlines);
|
|
}
|
|
generateReflowCommand = PR_TRUE;
|
|
target = anonymousBlockParent;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("RemoveFrame: case 4\n");
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
// We are removing the first block child of the anonymous
|
|
// block. We must gather all of the inline frames that
|
|
// follow the block being removed from the anonymous block
|
|
// so that they can be moved outside the anonymous block and
|
|
// into an inline frame.
|
|
|
|
// Take away the first frame from the anonymous block (which
|
|
// is the frame we are trying to remove). Make sure we
|
|
// remove aOldFrame's continuations if it has any...
|
|
nsInlineFrame* anonymousBlockParent;
|
|
anonymousBlock->GetParent((nsIFrame**) &anonymousBlockParent);
|
|
anonymousBlock->RemoveFirstFrame();
|
|
aOldFrame->GetNextInFlow(nextInFlow);
|
|
aOldFrame->DeleteFrame(aPresContext);
|
|
while (nsnull != nextInFlow) {
|
|
nsIFrame* nextParent;
|
|
nextInFlow->GetParent(&nextParent);
|
|
if (nextParent != anonymousBlock) {
|
|
anonymousBlock = (nsAnonymousBlockFrame*) nextParent;
|
|
}
|
|
anonymousBlock->RemoveFirstFrame();
|
|
nsIFrame* nextNextInFlow;
|
|
nextInFlow->GetNextInFlow(nextNextInFlow);
|
|
nextInFlow->DeleteFrame(aPresContext);
|
|
nextInFlow = nextNextInFlow;
|
|
}
|
|
|
|
// Gather up the inline frames that follow aOldFrame
|
|
nsFrameList frames;
|
|
PRBool done = PR_FALSE;
|
|
while (!done && (nsnull != anonymousBlock)) {
|
|
nsIFrame* kid;
|
|
anonymousBlock->FirstChild(nsnull, &kid);
|
|
while (nsnull != kid) {
|
|
if (nsLineLayout::TreatFrameAsBlock(kid)) {
|
|
done = PR_TRUE;
|
|
break;
|
|
}
|
|
nsIFrame* next;
|
|
kid->GetNextSibling(&next);
|
|
anonymousBlock->RemoveFirstFrame();
|
|
frames.AppendFrame(nsnull, kid);
|
|
kid = next;
|
|
}
|
|
anonymousBlock->GetNextInFlow((nsIFrame*&) anonymousBlock);
|
|
}
|
|
|
|
if (frames.NotEmpty()) {
|
|
// If the anonymousBlockParent has a prev-in-flow then
|
|
// append the inline frames there, otherwise insert them
|
|
// before the anonymousBlock.
|
|
anonymousBlockParent->GetPrevInFlow(prevInFlow);
|
|
if (nsnull != prevInFlow) {
|
|
anonymousBlockParent = (nsInlineFrame*) prevInFlow;
|
|
anonymousBlockParent->mFrames.AppendFrames(anonymousBlockParent,
|
|
frames);
|
|
}
|
|
else {
|
|
anonymousBlockParent->mFrames.InsertFrames(anonymousBlockParent,
|
|
nsnull,
|
|
frames);
|
|
}
|
|
}
|
|
generateReflowCommand = PR_TRUE;
|
|
target = anonymousBlockParent;
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("RemoveFrame: case 5\n");
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
// We can let the anonymousBlock remove the frame directly
|
|
#ifdef NOISY_ANON_BLOCK
|
|
printf("RemoveFrame: case 6\n");
|
|
#endif
|
|
anonymousBlock->RemoveFrame2(aPresContext, aPresShell, aListName,
|
|
aOldFrame);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (generateReflowCommand) {
|
|
// generate a reflow command for "this"
|
|
nsIReflowCommand* reflowCmd = nsnull;
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, target,
|
|
nsIReflowCommand::ReflowDirty);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
aPresShell.AppendReflowCommand(reflowCmd);
|
|
NS_RELEASE(reflowCmd);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Reflow methods
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::Reflow(nsIPresContext& aPresContext,
|
|
nsHTMLReflowMetrics& aMetrics,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DrainOverflow();
|
|
|
|
ReflowState rs(aPresContext, aReflowState, aMetrics,
|
|
(nsInlineFrame*) mNextInFlow);
|
|
|
|
// Peel off the next frame in the path if this is an incremental
|
|
// reflow aimed at one of the children.
|
|
if (eReflowReason_Incremental == aReflowState.reason) {
|
|
nsIFrame* target;
|
|
rs.reflowCommand->GetTarget(target);
|
|
if (this != target) {
|
|
rs.reflowCommand->GetNext(rs.mNextRCFrame);
|
|
}
|
|
}
|
|
|
|
nsresult rv;
|
|
if (mFrames.IsEmpty()) {
|
|
#ifdef HAVE_ANONYMOUS_BLOCK
|
|
NS_ASSERTION(!HaveAnonymousBlock(), "bad state");
|
|
#endif
|
|
|
|
// Try to pull over one frame before starting so that we know what
|
|
// state the HAVE_ANONYMOUS_BLOCK flag should be in.
|
|
nsIFrame* frame = PullAnyFrame(rs);
|
|
if (nsnull != frame) {
|
|
#ifdef HAVE_ANONYMOUS_BLOCK
|
|
if (nsLineLayout::TreatFrameAsBlock(frame)) {
|
|
mState |= HAVE_ANONYMOUS_BLOCK;
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
aMetrics.width = 0;
|
|
aMetrics.height = 0;
|
|
aMetrics.ascent = 0;
|
|
aMetrics.descent = 0;
|
|
aMetrics.mCarriedOutTopMargin = 0;
|
|
aMetrics.mCarriedOutBottomMargin = 0;
|
|
aMetrics.mCombinedArea.SetRect(0, 0, 0, 0);
|
|
if (nsnull != aMetrics.maxElementSize) {
|
|
aMetrics.maxElementSize->SizeTo(0, 0);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
if (HaveAnonymousBlock()) {
|
|
if ((nsnull != aReflowState.lineLayout) &&
|
|
(0 != aReflowState.lineLayout->GetPlacedFrames())) {
|
|
// This inline frame cannot be placed on the current line
|
|
// because there already is an inline frame on this line (and we
|
|
// contain an anonymous block).
|
|
aStatus = NS_INLINE_LINE_BREAK_BEFORE();
|
|
rv = NS_OK;
|
|
}
|
|
else {
|
|
rv = ReflowBlockFrame(rs, aMetrics, aStatus);
|
|
}
|
|
}
|
|
else {
|
|
if (nsnull != aReflowState.lineLayout) {
|
|
rv = ReflowInlineFrames(rs, aMetrics, aStatus);
|
|
}
|
|
else {
|
|
rv = NS_ERROR_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// If the combined area of our children exceeds our bounding box
|
|
// then set the NS_FRAME_OUTSIDE_CHILDREN flag, otherwise clear it.
|
|
if ((aMetrics.mCombinedArea.x < 0) ||
|
|
(aMetrics.mCombinedArea.y < 0) ||
|
|
(aMetrics.mCombinedArea.XMost() > aMetrics.width) ||
|
|
(aMetrics.mCombinedArea.YMost() > aMetrics.height)) {
|
|
mState |= NS_FRAME_OUTSIDE_CHILDREN;
|
|
}
|
|
else {
|
|
mState &= ~NS_FRAME_OUTSIDE_CHILDREN;
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsInlineFrame::DrainOverflow()
|
|
{
|
|
PRBool changedFirstFrame = PR_FALSE;
|
|
|
|
// Check for an overflow list with our prev-in-flow
|
|
nsInlineFrame* prevInFlow = (nsInlineFrame*)mPrevInFlow;
|
|
if (nsnull != prevInFlow) {
|
|
if (prevInFlow->mOverflowFrames.NotEmpty()) {
|
|
mFrames.InsertFrames(this, nsnull, prevInFlow->mOverflowFrames);
|
|
changedFirstFrame = PR_TRUE;
|
|
}
|
|
}
|
|
|
|
// It's also possible that we have an overflow list for ourselves
|
|
if (mOverflowFrames.NotEmpty()) {
|
|
NS_ASSERTION(mFrames.NotEmpty(), "overflow list w/o frames");
|
|
mFrames.Join(nsnull, mOverflowFrames);
|
|
}
|
|
|
|
#ifdef HAVE_ANONYMOUS_BLOCK
|
|
if (changedFirstFrame) {
|
|
// Update our HAVE_ANONYMOUS_BLOCK state bit in case our first
|
|
// child has changed to a new frame.
|
|
nsIFrame* frame = mFrames.FirstChild();
|
|
if (nsLineLayout::TreatFrameAsBlock(frame)) {
|
|
mState |= HAVE_ANONYMOUS_BLOCK;
|
|
}
|
|
else {
|
|
mState &= ~HAVE_ANONYMOUS_BLOCK;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
nsresult
|
|
nsInlineFrame::ReflowInlineFrames(ReflowState& rs,
|
|
nsHTMLReflowMetrics& aMetrics,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
nsInlineReflow ir(*rs.lineLayout, rs, this, PR_FALSE);
|
|
rs.inlineReflow = &ir;
|
|
rs.lineLayout->PushInline(&ir);
|
|
|
|
// Compute available area
|
|
nscoord x = rs.mBorderPadding.left;
|
|
nscoord availableWidth = rs.availableWidth;
|
|
if (NS_UNCONSTRAINEDSIZE != availableWidth) {
|
|
if (nsnull != mPrevInFlow) {
|
|
x = 0;
|
|
availableWidth -= rs.mBorderPadding.right;
|
|
}
|
|
else {
|
|
availableWidth -= rs.mBorderPadding.left + rs.mBorderPadding.right;
|
|
}
|
|
}
|
|
nscoord y = rs.mBorderPadding.top;
|
|
nscoord availableHeight = rs.availableHeight;
|
|
if (NS_UNCONSTRAINEDSIZE != rs.availableHeight) {
|
|
availableHeight -= rs.mBorderPadding.top + rs.mBorderPadding.right;
|
|
}
|
|
ir.Init(x, y, availableWidth, availableHeight);
|
|
|
|
// First reflow our current children
|
|
nsIFrame* frame = mFrames.FirstChild();
|
|
PRBool done = PR_FALSE;
|
|
while (nsnull != frame) {
|
|
rv = ReflowInlineFrame(rs, frame, aStatus);
|
|
if (NS_FAILED(rv) || (NS_FRAME_COMPLETE != aStatus)) {
|
|
done = PR_TRUE;
|
|
break;
|
|
}
|
|
rs.prevFrame = frame;
|
|
frame->GetNextSibling(&frame);
|
|
}
|
|
|
|
// Attempt to pull frames from our next-in-flow until we can't
|
|
if (!done && (nsnull != mNextInFlow)) {
|
|
while (!done) {
|
|
PRBool isComplete;
|
|
frame = PullInlineFrame(rs, &isComplete);
|
|
if (nsnull == frame) {
|
|
if (!isComplete) {
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
}
|
|
break;
|
|
}
|
|
rv = ReflowInlineFrame(rs, frame, aStatus);
|
|
if (NS_FAILED(rv) || (NS_FRAME_COMPLETE != aStatus)) {
|
|
done = PR_TRUE;
|
|
break;
|
|
}
|
|
rs.prevFrame = frame;
|
|
}
|
|
}
|
|
|
|
// Compute final metrics
|
|
if (NS_SUCCEEDED(rv)) {
|
|
#ifdef NS_DEBUG
|
|
if (NS_FRAME_COMPLETE == aStatus) {
|
|
NS_ASSERTION(mOverflowFrames.IsEmpty(), "whoops");
|
|
}
|
|
#endif
|
|
nsInlineReflow* ir = rs.inlineReflow;
|
|
nsRect bbox;
|
|
ir->VerticalAlignFrames(bbox, aMetrics.ascent, aMetrics.descent);
|
|
// XXX what about our border/padding and the combined area?
|
|
ir->RelativePositionFrames(aMetrics.mCombinedArea);
|
|
aMetrics.width = bbox.width;
|
|
if (NS_FRAME_IS_COMPLETE(aStatus)) {
|
|
aMetrics.width += rs.mBorderPadding.right;
|
|
}
|
|
aMetrics.height = bbox.height;
|
|
aMetrics.mCarriedOutTopMargin = 0;
|
|
aMetrics.mCarriedOutBottomMargin = 0;
|
|
if (nsnull != aMetrics.maxElementSize) {
|
|
*aMetrics.maxElementSize = ir->GetMaxElementSize();
|
|
}
|
|
}
|
|
rs.lineLayout->PopInline();
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsInlineFrame::ReflowInlineFrame(ReflowState& rs,
|
|
nsIFrame* aFrame,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
// Make sure that we don't reflow a block frame when we run across
|
|
// one. This can easily happen if this inline has a mixture of
|
|
// frames (note that an anonymous block frame is used to wrap up the
|
|
// direct block children of this inline therefore when we do run
|
|
// across a block frame its an anonymous block).
|
|
if (nsLineLayout::TreatFrameAsBlock(aFrame)) {
|
|
NS_ASSERTION(aFrame != mFrames.FirstChild(), "bad anon-block status");
|
|
PushFrames(aFrame, rs.prevFrame);
|
|
aStatus = NS_INLINE_LINE_BREAK_AFTER(NS_FRAME_NOT_COMPLETE);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsInlineReflow* ir = rs.inlineReflow;
|
|
nsresult rv = ir->ReflowFrame(aFrame, PR_FALSE/* XXX */, aStatus);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
if (NS_INLINE_IS_BREAK(aStatus)) {
|
|
if (NS_INLINE_IS_BREAK_BEFORE(aStatus)) {
|
|
if (aFrame != mFrames.FirstChild()) {
|
|
// Change break-before status into break-after since we have
|
|
// already placed at least one child frame. This preserves the
|
|
// break-type so that it can be propogated upward.
|
|
aStatus = NS_FRAME_NOT_COMPLETE |
|
|
NS_INLINE_BREAK | NS_INLINE_BREAK_AFTER |
|
|
(aStatus & NS_INLINE_BREAK_TYPE_MASK);
|
|
PushFrames(aFrame, rs.prevFrame);
|
|
}
|
|
else {
|
|
// Preserve reflow status when breaking-before our first child
|
|
// and propogate it upward without modification.
|
|
}
|
|
}
|
|
else {
|
|
// Break-after
|
|
if (NS_FRAME_IS_NOT_COMPLETE(aStatus)) {
|
|
nsIFrame* newFrame;
|
|
rv = CreateNextInFlow(rs.mPresContext, this, aFrame, newFrame);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
}
|
|
nsIFrame* nextFrame;
|
|
aFrame->GetNextSibling(&nextFrame);
|
|
if (nsnull != nextFrame) {
|
|
aStatus |= NS_FRAME_NOT_COMPLETE;
|
|
PushFrames(nextFrame, aFrame);
|
|
}
|
|
else if (nsnull != mNextInFlow) {
|
|
// We must return an incomplete status if there are more child
|
|
// frames remaining in a next-in-flow that follows this frame.
|
|
nsInlineFrame* nextInFlow = (nsInlineFrame*) mNextInFlow;
|
|
while (nsnull != nextInFlow) {
|
|
if (nextInFlow->mFrames.NotEmpty()) {
|
|
aStatus |= NS_FRAME_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
nextInFlow = (nsInlineFrame*) nextInFlow->mNextInFlow;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (NS_FRAME_IS_NOT_COMPLETE(aStatus)) {
|
|
nsIFrame* newFrame;
|
|
rv = CreateNextInFlow(rs.mPresContext, this, aFrame, newFrame);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
nsIFrame* nextFrame;
|
|
aFrame->GetNextSibling(&nextFrame);
|
|
if (nsnull != nextFrame) {
|
|
PushFrames(nextFrame, aFrame);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsIFrame*
|
|
nsInlineFrame::PullInlineFrame(ReflowState& rs, PRBool* aIsComplete)
|
|
{
|
|
PRBool isComplete = PR_TRUE;
|
|
|
|
nsIFrame* frame = nsnull;
|
|
nsInlineFrame* nextInFlow = rs.nextInFlow;
|
|
while (nsnull != nextInFlow) {
|
|
if (nextInFlow->HaveAnonymousBlock()) {
|
|
isComplete = PR_FALSE;
|
|
break;
|
|
}
|
|
frame = mFrames.PullFrame(this, rs.prevFrame, nextInFlow->mFrames);
|
|
if (nsnull != frame) {
|
|
isComplete = PR_FALSE;
|
|
break;
|
|
}
|
|
nextInFlow = (nsInlineFrame*) nextInFlow->mNextInFlow;
|
|
rs.nextInFlow = nextInFlow;
|
|
}
|
|
|
|
*aIsComplete = isComplete;
|
|
return frame;
|
|
}
|
|
|
|
nsIFrame*
|
|
nsInlineFrame::PullAnyFrame(ReflowState& rs)
|
|
{
|
|
nsIFrame* frame = nsnull;
|
|
nsInlineFrame* nextInFlow = rs.nextInFlow;
|
|
while (nsnull != nextInFlow) {
|
|
frame = mFrames.PullFrame(this, rs.prevFrame, nextInFlow->mFrames);
|
|
if (nsnull != frame) {
|
|
#ifdef HAVE_ANONYMOUS_BLOCK
|
|
nsIFrame* first = nextInFlow->mFrames.FirstChild();
|
|
if (nsnull != first) {
|
|
if (nsLineLayout::TreatFrameAsBlock(first)) {
|
|
nextInFlow->mState |= HAVE_ANONYMOUS_BLOCK;
|
|
}
|
|
else {
|
|
nextInFlow->mState &= ~HAVE_ANONYMOUS_BLOCK;
|
|
}
|
|
}
|
|
else {
|
|
// Since next-in-flow has no more frames, it can't have a
|
|
// block frame so clear out the state that indicates that.
|
|
nextInFlow->mState &= ~HAVE_ANONYMOUS_BLOCK;
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
#ifdef HAVE_ANONYMOUS_BLOCK
|
|
// Since next-in-flow has no more frames, it can't have a block
|
|
// frame so clear out the state that indicates that.
|
|
nextInFlow->mState &= ~HAVE_ANONYMOUS_BLOCK;
|
|
#endif
|
|
|
|
nextInFlow = (nsInlineFrame*) nextInFlow->mNextInFlow;
|
|
rs.nextInFlow = nextInFlow;
|
|
}
|
|
|
|
return frame;
|
|
}
|
|
|
|
void
|
|
nsInlineFrame::PushFrames(nsIFrame* aFromChild, nsIFrame* aPrevSibling)
|
|
{
|
|
NS_PRECONDITION(nsnull != aFromChild, "null pointer");
|
|
NS_PRECONDITION(nsnull != aPrevSibling, "pushing first child");
|
|
#ifdef NS_DEBUG
|
|
nsIFrame* prevNextSibling;
|
|
aPrevSibling->GetNextSibling(&prevNextSibling);
|
|
NS_PRECONDITION(prevNextSibling == aFromChild, "bad prev sibling");
|
|
#endif
|
|
|
|
// Disconnect aFromChild from its previous sibling
|
|
aPrevSibling->SetNextSibling(nsnull);
|
|
|
|
// Add the frames to our overflow list (let our next in flow drain
|
|
// our overflow list when it is ready)
|
|
NS_ASSERTION(mOverflowFrames.IsEmpty(), "bad overflow list");
|
|
mOverflowFrames.SetFrames(aFromChild);
|
|
}
|
|
|
|
nsresult
|
|
nsInlineFrame::ReflowBlockFrame(ReflowState& rs,
|
|
nsHTMLReflowMetrics& aMetrics,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
nsIFrame* blockFrame = mFrames.FirstChild();
|
|
|
|
// Compute available area
|
|
nscoord x = rs.mBorderPadding.left;
|
|
nscoord availableWidth = rs.availableWidth;
|
|
if (NS_UNCONSTRAINEDSIZE != availableWidth) {
|
|
if (nsnull != mPrevInFlow) {
|
|
x = 0;
|
|
availableWidth -= rs.mBorderPadding.right;
|
|
}
|
|
else {
|
|
availableWidth -= rs.mBorderPadding.left + rs.mBorderPadding.right;
|
|
}
|
|
}
|
|
nscoord y = rs.mBorderPadding.top;
|
|
nscoord availableHeight = rs.availableHeight;
|
|
if (NS_UNCONSTRAINEDSIZE != rs.availableHeight) {
|
|
availableHeight -= rs.mBorderPadding.top + rs.mBorderPadding.right;
|
|
}
|
|
|
|
// Reflow the block frame
|
|
// XXX Stop passing in line-layout to block-reflow-context
|
|
nsBlockReflowContext bc(rs.mPresContext, *rs.lineLayout, rs);
|
|
nsRect availSpace(x, y, availableWidth, availableHeight);
|
|
PRBool isAdjacentWithTop = PR_FALSE;
|
|
nsMargin computedOffsets;
|
|
nsresult rv = bc.ReflowBlock(blockFrame, availSpace, isAdjacentWithTop,
|
|
computedOffsets, aStatus);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
if (NS_INLINE_IS_BREAK_BEFORE(aStatus)) {
|
|
// We need to break before placing the block so propogate that
|
|
// status outward to our parent.
|
|
}
|
|
else {
|
|
// Place the block (during placement we might discover that none
|
|
// of it fits)
|
|
nsRect bounds;
|
|
PRBool anyFit = bc.PlaceBlock(isAdjacentWithTop, PR_FALSE,
|
|
0, computedOffsets,
|
|
bounds, aMetrics.mCombinedArea);
|
|
if (!anyFit) {
|
|
// None of the block fit
|
|
aStatus = NS_INLINE_LINE_BREAK_BEFORE();
|
|
}
|
|
else {
|
|
if (NS_FRAME_IS_NOT_COMPLETE(aStatus)) {
|
|
// When the block isn't complete create a continuation for it
|
|
nsIFrame* newFrame;
|
|
rv = CreateNextInFlow(rs.mPresContext, this, blockFrame, newFrame);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
// It's possible that the block frame is followed by one or more
|
|
// inline frames. Make sure we reflect that in our reflow status
|
|
// and push them to our next-in-flow.
|
|
nsIFrame* nextFrame;
|
|
blockFrame->GetNextSibling(&nextFrame);
|
|
if (nsnull != nextFrame) {
|
|
PushFrames(nextFrame, blockFrame);
|
|
aStatus |= NS_FRAME_NOT_COMPLETE;
|
|
}
|
|
else if (NS_FRAME_IS_COMPLETE(aStatus)) {
|
|
// When the block we reflowed is complete then we need to
|
|
// check and see if there are other frames (inline frames)
|
|
// following in our continuations so that we return the proper
|
|
// reflow status.
|
|
nsInlineFrame* nextInFlow = (nsInlineFrame*) mNextInFlow;
|
|
while (nsnull != nextInFlow) {
|
|
if (nextInFlow->mFrames.NotEmpty() ||
|
|
nextInFlow->mOverflowFrames.NotEmpty()) {
|
|
aStatus |= NS_FRAME_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
nextInFlow = (nsInlineFrame*) nextInFlow->mNextInFlow;
|
|
}
|
|
}
|
|
|
|
// XXX factor in border/padding
|
|
aMetrics.width = bounds.width;
|
|
aMetrics.height = bounds.height;
|
|
aMetrics.ascent = bounds.height;
|
|
aMetrics.descent = 0;
|
|
aMetrics.mCarriedOutTopMargin = bc.GetCollapsedTopMargin();
|
|
aMetrics.mCarriedOutBottomMargin = bc.GetCarriedOutBottomMargin();
|
|
if (nsnull != aMetrics.maxElementSize) {
|
|
*aMetrics.maxElementSize = bc.GetMaxElementSize();
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
NS_IMETHODIMP
|
|
nsInlineFrame::CreateContinuingFrame(nsIPresContext& aPresContext,
|
|
nsIFrame* aParent,
|
|
nsIStyleContext* aStyleContext,
|
|
nsIFrame*& aContinuingFrame)
|
|
{
|
|
nsInlineFrame* cf = new nsInlineFrame;
|
|
if (nsnull == cf) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
cf->Init(aPresContext, mContent, aParent, aStyleContext);
|
|
cf->AppendToFlow(this);
|
|
aContinuingFrame = cf;
|
|
return NS_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
PRIntn
|
|
nsInlineFrame::GetSkipSides() const
|
|
{
|
|
PRIntn skip = 0;
|
|
if (nsnull != mPrevInFlow) {
|
|
skip |= 1 << NS_SIDE_LEFT;
|
|
}
|
|
if (nsnull != mNextInFlow) {
|
|
skip |= 1 << NS_SIDE_RIGHT;
|
|
}
|
|
return skip;
|
|
}
|