mozilla
/
pjs
зеркало из https://github.com/mozilla/pjs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Changed nsIFrame member functions to return a nsresult

This commit is contained in:
troy 1998-04-17 01:41:24 +00:00
Родитель 594ca982cb
Коммит d504fcfb0c
100 изменённых файлов: 4538 добавлений и 2991 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

14
content/base/src/nsStyleContext.cpp
Просмотреть файл

@ -526,7 +526,9 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
// It's text (!)
mMolecule.display = NS_STYLE_DISPLAY_INLINE;
mMolecule.cursor = NS_STYLE_CURSOR_IBEAM;
nsIContent* content = aParentFrame->GetContent();
nsIContent* content;
aParentFrame->GetContent(content);
nsIAtom* parentTag = content->GetTag();
parentTag->ToString(buf);
NS_RELEASE(content);
@ -539,9 +541,13 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
// mFont.mFont.decorations = NS_FONT_DECORATION_UNDERLINE;
// This simulates a <PRE><A>text inheritance rule
// Check the parent of the A
nsIFrame* parentParentFrame = aParentFrame->GetGeometricParent();
nsIFrame* parentParentFrame;
aParentFrame->GetGeometricParent(parentParentFrame);
if (nsnull != parentParentFrame) {
nsIContent* parentParentContent = parentParentFrame->GetContent();
nsIContent* parentParentContent;
parentParentFrame->GetContent(parentParentContent);
nsIAtom* parentParentTag = parentParentContent->GetTag();
parentParentTag->ToString(buf);
NS_RELEASE(parentParentTag);
@ -607,7 +613,7 @@ NS_NewStyleContext(nsIStyleContext** aInstancePtrResult,
nsIStyleContext* parent = nsnull;
if (nsnull != aParentFrame) {
parent = aParentFrame->GetStyleContext(aPresContext);
aParentFrame->GetStyleContext(aPresContext, parent);
NS_ASSERTION(nsnull != parent, "parent frame must have style context");
}

2
content/base/src/nsStyleSet.cpp
Просмотреть файл

@ -454,7 +454,7 @@ nsIStyleContext* StyleSetImpl::ResolveStyleFor(nsIPresContext* aPresContext,
nsIStyleContext* parentContext = nsnull;
if (nsnull != aParentFrame) {
parentContext = aParentFrame->GetStyleContext(aPresContext);
aParentFrame->GetStyleContext(aPresContext, parentContext);
NS_ASSERTION(nsnull != parentContext, "parent must have style context");
}

29
content/html/style/src/nsCSSLayout.cpp
Просмотреть файл

@ -54,8 +54,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
PRIntn kidCount = aChildCount;
while (--kidCount >= 0) {
nscoord kidAscent = *aAscents++;
nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
nsIContent* kidContent = kid->GetContent();
nsIStyleContext* kidSC;
nsIContent* kidContent;
kid->GetStyleContext(aCX, kidSC);
kid->GetContent(kidContent);
nsStyleMolecule* kidMol =
(nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
PRIntn verticalAlign = kidMol->verticalAlign;
@ -124,7 +127,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
y += kidRect.height;
if (y > maxY) maxY = y;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
nscoord lineHeight = maxY - minY;
@ -135,8 +138,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
kid = aFirstChild;
while (--kidCount >= 0) {
// Get kid's vertical align style data
nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
nsIContent* kidContent = kid->GetContent();
nsIStyleContext* kidSC;
nsIContent* kidContent;
kid->GetStyleContext(aCX, kidSC);
kid->GetContent(kidContent);
nsStyleMolecule* kidMol =
(nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
PRIntn verticalAlign = kidMol->verticalAlign;
@ -154,7 +160,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
}
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
@ -197,7 +203,7 @@ void nsCSSLayout::HorizontallyPlaceChildren(nsIPresContext* aCX,
while (--aChildCount >= 0) {
kid->GetOrigin(origin);
kid->MoveTo(origin.x + dx, origin.y);
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
@ -213,8 +219,11 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
nsPoint origin;
nsIFrame* kid = aFirstChild;
while (--aChildCount >= 0) {
nsIContent* kidContent = kid->GetContent();
nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
nsIContent* kidContent;
nsIStyleContext* kidSC;
kid->GetContent(kidContent);
kid->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
if (NS_STYLE_POSITION_RELATIVE == kidMol->positionFlags) {
kid->GetOrigin(origin);
@ -224,6 +233,6 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
}
NS_RELEASE(kidContent);
NS_RELEASE(kidSC);
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}

6
content/html/style/src/nsCSSStyleSheet.cpp
Просмотреть файл

@ -215,11 +215,13 @@ PRInt32 CSSStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
selector = selector->mNext;
nsIFrame* frame = aParentFrame;
while ((nsnull != selector) && (nsnull != frame)) { // check compound selectors
nsIContent* content = frame->GetContent();
nsIContent* content;
frame->GetContent(content);
if (SelectorMatches(selector, content)) {
selector = selector->mNext;
}
frame = frame->GetGeometricParent();
frame->GetGeometricParent(frame);
NS_RELEASE(content);
}
if (nsnull == selector) { // ran out, it matched

12
layout/base/nsPresContext.cpp
Просмотреть файл

@ -190,7 +190,9 @@ void ImageLoader::UpdateFrames()
nsIFrame* frame = (nsIFrame*) mFrames.ElementAt(i);
// XXX installed colormap should be presentation-context/window state
nsIWidget* window = frame->GetWindow();
nsIWidget* window;
frame->GetWindow(window);
if (!gXXXInstalledColorMap && mImage) {
nsColorMap* cmap = mImage->GetColorMap();
if ((nsnull != cmap) && (cmap->NumColors > 0)) {
@ -203,7 +205,9 @@ void ImageLoader::UpdateFrames()
nsPoint offset;
nsRect bounds;
frame->GetRect(bounds);
nsIView* view = frame->GetOffsetFromView(offset);
nsIView* view;
frame->GetOffsetFromView(offset, view);
nsIViewManager* vm = view->GetViewManager();
bounds.x = offset.x;
bounds.y = offset.y;
@ -360,7 +364,9 @@ nsIImage* nsPresContext::LoadImage(const nsString& aURL, nsIFrame* aForFrame)
if (nsnull == mImageGroup) {
// XXX this is bad; if we allow for subwindows that have different
// rendering context's this won't work
nsIWidget* window = aForFrame->GetWindow();
nsIWidget* window;
aForFrame->GetWindow(window);
nsIRenderingContext* drawCtx = window->GetRenderingContext();
drawCtx->Scale(mDeviceContext->GetAppUnitsToDevUnits(),
mDeviceContext->GetAppUnitsToDevUnits());

199
layout/base/public/nsIFrame.h
Просмотреть файл

@ -34,12 +34,10 @@ class nsIView;
class nsIWidget;
class nsReflowCommand;
struct nsStyleStruct;
struct nsGUIEvent;
struct nsPoint;
struct nsRect;
struct nsReflowMetrics;
struct nsStyleStruct;
// IID for the nsIFrame interface {12B193D0-9F70-11d1-8500-00A02468FAB6}
#define NS_IFRAME_IID \
@ -81,13 +79,13 @@ public:
* QueryInterface() defined in nsISupports. This is the only member
* function of nsISupports that is public.
*/
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
/**
* Deletes this frame and each of its child frames (recursively calls
* DeleteFrame() for each child)
*/
virtual void DeleteFrame() = 0;
NS_IMETHOD DeleteFrame() = 0;
/**
* Get the content object associated with this frame. Adds a reference to
@ -95,66 +93,73 @@ public:
*
* @see nsISupports#Release()
*/
virtual nsIContent* GetContent() const = 0;
NS_IMETHOD GetContent(nsIContent*& aContent) const = 0;
/**
* Get/Set the frame's index in parent.
*/
virtual PRInt32 GetIndexInParent() const = 0;
virtual void SetIndexInParent(PRInt32 aIndexInParent) = 0;
NS_IMETHOD GetIndexInParent(PRInt32& aIndexInParent) const = 0;
NS_IMETHOD SetIndexInParent(PRInt32 aIndexInParent) = 0;
/**
* Get the style context associated with this frame. Note that GetStyleContext()
* adds a reference to the style context so the caller must do a release.
*
* @see #nsISupports#Release()
* @see nsISupports#Release()
*/
virtual nsIStyleContext* GetStyleContext(nsIPresContext* aContext) = 0;
virtual void SetStyleContext(nsIStyleContext* aContext) = 0;
NS_IMETHOD GetStyleContext(nsIPresContext* aContext,
nsIStyleContext*& aStyleContext) = 0;
NS_IMETHOD SetStyleContext(nsIStyleContext* aContext) = 0;
/**
*
* Get the style data associated with this frame
*
*
*/
virtual nsStyleStruct* GetStyleData(const nsIID& aSID) = 0;
NS_IMETHOD GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct) = 0;
/**
* Accessor functions for geometric and content parent.
*/
virtual nsIFrame* GetContentParent() const = 0;
virtual void SetContentParent(const nsIFrame* aParent) = 0;
virtual nsIFrame* GetGeometricParent() const = 0;
virtual void SetGeometricParent(const nsIFrame* aParent) = 0;
NS_IMETHOD GetContentParent(nsIFrame*& aParent) const = 0;
NS_IMETHOD SetContentParent(const nsIFrame* aParent) = 0;
NS_IMETHOD GetGeometricParent(nsIFrame*& aParent) const = 0;
NS_IMETHOD SetGeometricParent(const nsIFrame* aParent) = 0;
/**
* Bounding rect of the frame. The values are in twips, and the origin is
* relative to the upper-left of the geometric parent. The size includes the
* content area, borders, and padding.
*/
virtual nsRect GetRect() const = 0;
virtual void GetRect(nsRect& aRect) const = 0;
virtual void GetOrigin(nsPoint& aPoint) const = 0;
virtual nscoord GetWidth() const = 0;
virtual nscoord GetHeight() const = 0;
virtual void SetRect(const nsRect& aRect) = 0;
virtual void MoveTo(nscoord aX, nscoord aY) = 0;
virtual void SizeTo(nscoord aWidth, nscoord aHeight) = 0;
NS_IMETHOD GetRect(nsRect& aRect) const = 0;
NS_IMETHOD GetOrigin(nsPoint& aPoint) const = 0;
NS_IMETHOD GetSize(nsSize& aSize) const = 0;
NS_IMETHOD SetRect(const nsRect& aRect) = 0;
NS_IMETHOD MoveTo(nscoord aX, nscoord aY) = 0;
NS_IMETHOD SizeTo(nscoord aWidth, nscoord aHeight) = 0;
/**
* Child frame enumeration
*/
NS_IMETHOD ChildCount(PRInt32& aChildCount) const = 0;
NS_IMETHOD ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const = 0;
NS_IMETHOD IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const = 0;
NS_IMETHOD FirstChild(nsIFrame*& aFirstChild) const = 0;
NS_IMETHOD NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const = 0;
NS_IMETHOD PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const = 0;
NS_IMETHOD LastChild(nsIFrame*& aLastChild) const = 0;
/**
* Painting
*/
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect) = 0;
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect) = 0;
/**
* Handle an event.
*/
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent) = 0;
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus) = 0;
/**
* Get the cursor for a given point in the frame tree. The
@ -162,20 +167,10 @@ public:
* no cursor is wanted). In addition, if a cursor is desired
* then *aFrame is set to the frame that wants the cursor.
*/
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame) = 0;
/**
* Child frame enumeration
*/
virtual PRInt32 ChildCount() const = 0;
virtual nsIFrame* ChildAt(PRInt32 aIndex) const = 0;
virtual PRInt32 IndexOf(const nsIFrame* aChild) const = 0;
virtual nsIFrame* FirstChild() const = 0;
virtual nsIFrame* NextChild(const nsIFrame* aChild) const = 0;
virtual nsIFrame* PrevChild(const nsIFrame* aChild) const = 0;
virtual nsIFrame* LastChild() const = 0;
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor) = 0;
/**
* Reflow status returned by the reflow methods
@ -206,10 +201,11 @@ public:
* a maximum element size. The maximum element size must be less than or
* equal to your desired size.
*/
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize) = 0;
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus) = 0;
/**
* Post-processing reflow method invoked when justification is enabled.
@ -218,8 +214,8 @@ public:
* @param aAvailableSpace The amount of available space that the frame
* should distribute internally.
*/
virtual void JustifyReflow(nsIPresContext* aPresContext,
nscoord aAvailableSpace) = 0;
NS_IMETHOD JustifyReflow(nsIPresContext* aPresContext,
nscoord aAvailableSpace) = 0;
/**
* Incremental reflow. The reflow command contains information about the
@ -243,10 +239,11 @@ public:
* @see nsReflowCommand#GetTarget()
* @see nsReflowCommand#GetType()
*/
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand) = 0;
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus) = 0;
/**
* This call is invoked when content is appended to the content
@ -256,9 +253,9 @@ public:
* the call must generate reflow commands that will incrementally
* reflow and repair the damaged portion of the frame tree.
*/
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer) = 0;
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer) = 0;
/**
* This call is invoked when content is inserted in the content
@ -271,11 +268,11 @@ public:
* @param aIndexInParent the index in the content container where
* the new content was inserted.
*/
virtual void ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
NS_IMETHOD ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
/**
* This call is invoked when content is replaced in the content
@ -288,12 +285,12 @@ public:
*
* @param aIndexInParent the index in the content container where
* the new content was inserted. */
virtual void ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent) = 0;
NS_IMETHOD ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent) = 0;
/**
* This call is invoked when content is deleted from the content
@ -306,11 +303,11 @@ public:
* @param aIndexInParent the index in the content container where
* the new content was deleted.
*/
virtual void ContentDeleted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
NS_IMETHOD ContentDeleted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
/**
* Return the reflow metrics for this frame. If the frame is a
@ -320,43 +317,45 @@ public:
* ascent of the line's children). Note that the metrics returned
* apply to the frame as it exists at the time of the call.
*/
virtual void GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics) = 0;
NS_IMETHOD GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics) = 0;
/**
* Flow member functions. CreateContinuingFrame() is responsible for appending
* the continuing frame to the flow.
*/
virtual PRBool IsSplittable() const = 0;
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent) = 0;
virtual nsIFrame* GetPrevInFlow() const = 0;
virtual void SetPrevInFlow(nsIFrame*) = 0;
virtual nsIFrame* GetNextInFlow() const = 0;
virtual void SetNextInFlow(nsIFrame*) = 0;
NS_IMETHOD IsSplittable(PRBool& aIsSplittable) const = 0;
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame) = 0;
virtual void AppendToFlow(nsIFrame* aAfterFrame) = 0;
virtual void PrependToFlow(nsIFrame* aBeforeFrame) = 0;
virtual void RemoveFromFlow() = 0;
virtual void BreakFromPrevFlow() = 0;
virtual void BreakFromNextFlow() = 0;
NS_IMETHOD GetPrevInFlow(nsIFrame*& aPrevInFlow) const = 0;
NS_IMETHOD SetPrevInFlow(nsIFrame*) = 0;
NS_IMETHOD GetNextInFlow(nsIFrame*& aNextInFlow) const = 0;
NS_IMETHOD SetNextInFlow(nsIFrame*) = 0;
NS_IMETHOD AppendToFlow(nsIFrame* aAfterFrame) = 0;
NS_IMETHOD PrependToFlow(nsIFrame* aBeforeFrame) = 0;
NS_IMETHOD RemoveFromFlow() = 0;
NS_IMETHOD BreakFromPrevFlow() = 0;
NS_IMETHOD BreakFromNextFlow() = 0;
/**
* Accessor functions to get/set the associated view object
*/
virtual nsIView* GetView() const = 0; // may be null
virtual void SetView(nsIView* aView) = 0;
NS_IMETHOD GetView(nsIView*& aView) const = 0; // may be null
NS_IMETHOD SetView(nsIView* aView) = 0;
/**
* Find the first geometric parent that has a view
*/
virtual nsIFrame* GetParentWithView() const = 0;
NS_IMETHOD GetParentWithView(nsIFrame*& aParent) const = 0;
/**
* Returns the offset from this frame to the closest geometric parent that
* has a view. Also returns the containing view or null in case of error
*/
virtual nsIView* GetOffsetFromView(nsPoint& aOffset) const = 0;
NS_IMETHOD GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const = 0;
/**
* Returns the window that contains this frame. If this frame has a
@ -364,18 +363,18 @@ public:
* returned, otherwise this frame's geometric parent is checked
* recursively upwards.
*/
virtual nsIWidget* GetWindow() const = 0;
NS_IMETHOD GetWindow(nsIWidget*&) const = 0;
/**
* Sibling pointer used to link together frames
*/
virtual nsIFrame* GetNextSibling() const = 0;
virtual void SetNextSibling(nsIFrame* aNextSibling) = 0;
NS_IMETHOD GetNextSibling(nsIFrame*& aNextSibling) const = 0;
NS_IMETHOD SetNextSibling(nsIFrame* aNextSibling) = 0;
// Debugging
virtual void List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
virtual void ListTag(FILE* out = stdout) const = 0;
virtual void VerifyTree() const = 0;
NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
NS_IMETHOD ListTag(FILE* out = stdout) const = 0;
NS_IMETHOD VerifyTree() const = 0;
// Show frame borders when rendering
static NS_LAYOUT void ShowFrameBorders(PRBool aEnable);

22
layout/base/public/nsIRunaround.h
Просмотреть файл

@ -65,11 +65,12 @@ public:
*
* @see nsISpaceManager#Translate()
*/
virtual nsIFrame::ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize) = 0;
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
nsIFrame::ReflowStatus& aStatus) = 0;
/**
* Incremental reflow. The reflow command contains information about the
@ -100,11 +101,12 @@ public:
* @param aReflowCommand the reflow command contains information about the
* type of change.
*/
virtual nsIFrame::ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand) = 0;
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
nsIFrame::ReflowStatus& aStatus) = 0;
};
#endif /* nsIRunaround_h___ */

469
layout/base/src/nsContainerFrame.cpp
Просмотреть файл

@ -51,7 +51,9 @@ nsContainerFrame::~nsContainerFrame()
// we do all of this before our base class releases it's hold on the
// view.
for (nsIFrame* child = mFirstChild; child; ) {
nsIFrame* nextChild = child->GetNextSibling();
nsIFrame* nextChild;
child->GetNextSibling(nextChild);
child->DeleteFrame();
child = nextChild;
}
@ -80,108 +82,122 @@ void nsContainerFrame::PrepareContinuingFrame(nsIPresContext* aPresContext,
NS_RELEASE(styleContext);
}
nsIFrame*
nsContainerFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsContainerFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsIContentDelegate* contentDelegate = mContent->GetDelegate(aPresContext);
nsContainerFrame* continuingFrame = (nsContainerFrame*)
contentDelegate->CreateFrame(aPresContext, mContent, mIndexInParent,
aParent);
aContinuingFrame = contentDelegate->CreateFrame(aPresContext, mContent,
mIndexInParent, aParent);
NS_RELEASE(contentDelegate);
PrepareContinuingFrame(aPresContext, aParent, continuingFrame);
return continuingFrame;
PrepareContinuingFrame(aPresContext, aParent, (nsContainerFrame*)aContinuingFrame);
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////////
// Child frame enumeration
PRInt32 nsContainerFrame::ChildCount() const
NS_METHOD nsContainerFrame::ChildCount(PRInt32& aChildCount) const
{
return mChildCount;
aChildCount = mChildCount;
return NS_OK;
}
nsIFrame* nsContainerFrame::ChildAt(PRInt32 aIndex) const
NS_METHOD nsContainerFrame::ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const
{
// Check that the index is in range
if ((aIndex < 0) || (aIndex >= mChildCount)) {
return nsnull;
aFrame = nsnull;
return NS_OK;
}
nsIFrame* result = mFirstChild;
while ((aIndex-- > 0) && (result != nsnull)) {
result = result->GetNextSibling();
aFrame = mFirstChild;
while ((aIndex-- > 0) && (aFrame != nsnull)) {
aFrame->GetNextSibling(aFrame);
}
return result;
return NS_OK;
}
PRInt32 nsContainerFrame::IndexOf(const nsIFrame* aChild) const
NS_METHOD nsContainerFrame::IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const
{
PRInt32 result = -1;
aIndex = -1; // initialize out parameter
for (nsIFrame* f = mFirstChild; f != nsnull; f = f->GetNextSibling()) {
result++;
for (nsIFrame* f = mFirstChild; f != nsnull; f->GetNextSibling(f)) {
aIndex++;
if (f == aChild)
break;
}
return result;
return NS_OK;
}
nsIFrame* nsContainerFrame::FirstChild() const
NS_METHOD nsContainerFrame::FirstChild(nsIFrame*& aFirstChild) const
{
return mFirstChild;
aFirstChild = mFirstChild;
return NS_OK;
}
nsIFrame* nsContainerFrame::NextChild(const nsIFrame* aChild) const
NS_METHOD nsContainerFrame::NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const
{
NS_PRECONDITION(aChild != nsnull, "null pointer");
return aChild->GetNextSibling();
aChild->GetNextSibling(aNextChild);
return NS_OK;
}
nsIFrame* nsContainerFrame::PrevChild(const nsIFrame* aChild) const
NS_METHOD nsContainerFrame::PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const
{
NS_PRECONDITION(aChild != nsnull, "null pointer");
nsIFrame* result;
if (mFirstChild == aChild) {
result = nsnull;
aPrevChild = nsnull;
} else {
result = mFirstChild;
aPrevChild = mFirstChild;
while ((result != nsnull) && (result->GetNextSibling() != aChild))
result = result->GetNextSibling();
while ((aPrevChild != nsnull)) {
nsIFrame* nextChild;
aPrevChild->GetNextSibling(nextChild);
if (nextChild == aChild) {
break;
}
aPrevChild = nextChild;
}
}
return result;
return NS_OK;
}
nsIFrame* nsContainerFrame::LastChild() const
NS_METHOD nsContainerFrame::LastChild(nsIFrame*& aLastChild) const
{
nsIFrame* result = mFirstChild;
aLastChild = mFirstChild;
if (result) {
while (result->GetNextSibling() != nsnull)
result = result->GetNextSibling();
if (nsnull != aLastChild) {
nsIFrame* nextChild;
aLastChild->GetNextSibling(nextChild);
while (nextChild != nsnull) {
aLastChild = nextChild;
aLastChild->GetNextSibling(nextChild);
}
}
return result;
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////////
// Painting
void nsContainerFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsContainerFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
// aDirtyRect is in our coordinate system
@ -192,7 +208,9 @@ void nsContainerFrame::PaintChildren(nsIPresContext& aPresContext,
{
nsIFrame* kid = mFirstChild;
while (nsnull != kid) {
nsIView *pView = kid->GetView();
nsIView *pView;
kid->GetView(pView);
if (nsnull == pView) {
nsRect kidRect;
kid->GetRect(kidRect);
@ -212,19 +230,21 @@ void nsContainerFrame::PaintChildren(nsIPresContext& aPresContext,
aRenderingContext.PopState();
}
}
else
else {
NS_RELEASE(pView);
kid = kid->GetNextSibling();
}
kid->GetNextSibling(kid);
}
}
/////////////////////////////////////////////////////////////////////////////
// Events
nsEventStatus nsContainerFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent)
NS_METHOD nsContainerFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
nsEventStatus retval = nsEventStatus_eIgnore;
aEventStatus = nsEventStatus_eIgnore;
nsIFrame* kid = mFirstChild;
while (nsnull != kid) {
@ -232,21 +252,22 @@ nsEventStatus nsContainerFrame::HandleEvent(nsIPresContext& aPresContext,
kid->GetRect(kidRect);
if (kidRect.Contains(aEvent->point)) {
aEvent->point.MoveBy(-kidRect.x, -kidRect.y);
retval = kid->HandleEvent(aPresContext, aEvent);
kid->HandleEvent(aPresContext, aEvent, aEventStatus);
aEvent->point.MoveBy(kidRect.x, kidRect.y);
return retval;
break;
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
return retval;
return NS_OK;
}
PRInt32 nsContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame)
NS_METHOD nsContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor)
{
PRInt32 retval = NS_STYLE_CURSOR_INHERIT;
aCursor = NS_STYLE_CURSOR_INHERIT;
nsIFrame* kid = mFirstChild;
nsPoint tmp;
@ -255,12 +276,12 @@ PRInt32 nsContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
kid->GetRect(kidRect);
if (kidRect.Contains(aPoint)) {
tmp.MoveTo(aPoint.x - kidRect.x, aPoint.y - kidRect.y);
retval = kid->GetCursorAt(aPresContext, tmp, aFrame);
return retval;
kid->GetCursorAt(aPresContext, tmp, aFrame, aCursor);
break;
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
return retval;
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////////
@ -293,13 +314,13 @@ PRInt32 nsContainerFrame::NextChildOffset() const
void nsContainerFrame::SetFirstContentOffset(const nsIFrame* aFirstChild)
{
NS_PRECONDITION(nsnull != aFirstChild, "bad argument");
NS_PRECONDITION(aFirstChild->GetGeometricParent() == this, "bad geometric parent");
NS_PRECONDITION(IsChild(aFirstChild), "bad geometric parent");
if (ChildIsPseudoFrame(aFirstChild)) {
nsContainerFrame* pseudoFrame = (nsContainerFrame*)aFirstChild;
mFirstContentOffset = pseudoFrame->mFirstContentOffset;
} else {
mFirstContentOffset = aFirstChild->GetIndexInParent();
aFirstChild->GetIndexInParent(mFirstContentOffset);
}
}
@ -311,7 +332,7 @@ void nsContainerFrame::SetFirstContentOffset(const nsIFrame* aFirstChild)
void nsContainerFrame::SetLastContentOffset(const nsIFrame* aLastChild)
{
NS_PRECONDITION(nsnull != aLastChild, "bad argument");
NS_PRECONDITION(aLastChild->GetGeometricParent() == this, "bad geometric parent");
NS_PRECONDITION(IsChild(aLastChild), "bad geometric parent");
if (ChildIsPseudoFrame(aLastChild)) {
nsContainerFrame* pseudoFrame = (nsContainerFrame*)aLastChild;
@ -321,15 +342,11 @@ void nsContainerFrame::SetLastContentOffset(const nsIFrame* aLastChild)
#endif
mLastContentIsComplete = pseudoFrame->mLastContentIsComplete;
} else {
mLastContentOffset = aLastChild->GetIndexInParent();
aLastChild->GetIndexInParent(mLastContentOffset);
}
#ifdef NS_DEBUG
if (mLastContentOffset < mFirstContentOffset) {
nsIFrame* top = this;
while (top->GetGeometricParent() != nsnull) {
top = top->GetGeometricParent();
}
top->List();
DumpTree();
}
#endif
NS_ASSERTION(mLastContentOffset >= mFirstContentOffset, "unexpected content mapping");
@ -344,8 +361,9 @@ PRBool nsContainerFrame::IsPseudoFrame() const
PRBool result = PR_FALSE;
if (nsnull != mGeometricParent) {
nsIContent* parentContent = mGeometricParent->GetContent();
nsIContent* parentContent;
mGeometricParent->GetContent(parentContent);
if (parentContent == mContent) {
result = PR_TRUE;
}
@ -358,10 +376,13 @@ PRBool nsContainerFrame::IsPseudoFrame() const
// Returns true if aChild is being used as a pseudo frame
PRBool nsContainerFrame::ChildIsPseudoFrame(const nsIFrame* aChild) const
{
NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
nsIContent* childContent = aChild->GetContent();
PRBool result = PRBool(childContent == mContent);
NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
nsIContent* childContent;
PRBool result;
aChild->GetContent(childContent);
result = PRBool(childContent == mContent);
NS_RELEASE(childContent);
return result;
}
@ -381,18 +402,22 @@ nsContainerFrame::ReflowChild(nsIFrame* aKidFrame,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
{
ReflowStatus status = aKidFrame->ResizeReflow(aPresContext, aDesiredSize,
aMaxSize, aMaxElementSize);
ReflowStatus status;
aKidFrame->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, status);
if (frComplete == status) {
nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
aKidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull != kidNextInFlow) {
// Remove all of the childs next-in-flows. Make sure that we ask
// the right parent to do the removal (it's possible that the
// parent is not this because we are executing pullup code)
nsContainerFrame* parent = (nsContainerFrame*)
aKidFrame->GetGeometricParent();
parent->DeleteChildsNextInFlow(aKidFrame);
nsIFrame* parent;
aKidFrame->GetGeometricParent(parent);
((nsContainerFrame*)parent)->DeleteChildsNextInFlow(aKidFrame);
}
}
return status;
@ -421,8 +446,8 @@ nsContainerFrame::ReflowChild(nsIFrame* aKidFrame,
// Does the child frame support interface nsIRunaround?
if (NS_OK == aKidFrame->QueryInterface(kIRunaroundIID, (void**)&reflowRunaround)) {
// Yes, the child frame wants to interact directly with the space manager
status = reflowRunaround->ResizeReflow(aPresContext, aSpaceManager, aMaxSize,
aDesiredRect, aMaxElementSize);
reflowRunaround->ResizeReflow(aPresContext, aSpaceManager, aMaxSize,
aDesiredRect, aMaxElementSize, status);
} else {
// No, use interface nsIFrame instead.
nsReflowMetrics desiredSize;
@ -456,8 +481,9 @@ nsContainerFrame::ReflowChild(nsIFrame* aKidFrame,
}
nsSize availSize(rects->width, aMaxSize.height);
status = aKidFrame->ResizeReflow(aPresContext, desiredSize, availSize,
aMaxElementSize);
aKidFrame->ResizeReflow(aPresContext, desiredSize, availSize,
aMaxElementSize, status);
// Return the desired rect
aDesiredRect.x = rects->x;
@ -467,14 +493,17 @@ nsContainerFrame::ReflowChild(nsIFrame* aKidFrame,
}
if (frComplete == status) {
nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
aKidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull != kidNextInFlow) {
// Remove all of the childs next-in-flows. Make sure that we ask
// the right parent to do the removal (it's possible that the
// parent is not this because we are executing pullup code)
nsContainerFrame* parent = (nsContainerFrame*)
aKidFrame->GetGeometricParent();
parent->DeleteChildsNextInFlow(aKidFrame);
nsIFrame* parent;
aKidFrame->GetGeometricParent(parent);
((nsContainerFrame*)parent)->DeleteChildsNextInFlow(aKidFrame);
}
}
return status;
@ -492,28 +521,42 @@ nsContainerFrame::ReflowChild(nsIFrame* aKidFrame,
*/
PRBool nsContainerFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
{
NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
NS_PRECONDITION(nsnull != aChild->GetNextInFlow(), "null next-in-flow");
NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
nsIFrame* nextInFlow = aChild->GetNextInFlow();
nsContainerFrame* parent = (nsContainerFrame*)nextInFlow->GetGeometricParent();
nsIFrame* nextInFlow;
nsContainerFrame* parent;
aChild->GetNextInFlow(nextInFlow);
NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
nextInFlow->GetGeometricParent((nsIFrame*&)parent);
// If the next-in-flow has a next-in-flow then delete it too (and
// If the next-in-flow has a next-in-flow then delete it, too (and
// delete it first).
if (nsnull != nextInFlow->GetNextInFlow()) {
parent->DeleteChildsNextInFlow(nextInFlow);
nsIFrame* nextNextInFlow;
nextInFlow->GetNextInFlow(nextNextInFlow);
if (nsnull != nextNextInFlow) {
((nsContainerFrame*)parent)->DeleteChildsNextInFlow(nextInFlow);
}
NS_ASSERTION((0 == nextInFlow->ChildCount()) &&
(nsnull == nextInFlow->FirstChild()),
"deleting !empty next-in-flow");
#ifdef NS_DEBUG
PRInt32 childCount;
nsIFrame* firstChild;
nextInFlow->ChildCount(childCount);
nextInFlow->FirstChild(firstChild);
NS_ASSERTION(childCount == 0, "deleting !empty next-in-flow");
NS_ASSERTION((0 == childCount) && (nsnull == firstChild), "deleting !empty next-in-flow");
#endif
// Disconnect the next-in-flow from the flow list
nextInFlow->BreakFromPrevFlow();
// Take the next-in-flow out of the parent's child list
if (parent->mFirstChild == nextInFlow) {
parent->mFirstChild = nextInFlow->GetNextSibling();
nextInFlow->GetNextSibling(parent->mFirstChild);
if (nsnull != parent->mFirstChild) {
parent->SetFirstContentOffset(parent->mFirstChild);
if (parent->IsPseudoFrame()) {
@ -530,15 +573,19 @@ PRBool nsContainerFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
// will be repaired.
} else {
nsIFrame* nextSibling;
// Because the next-in-flow is not the first child of the parent
// we know that it shares a parent with aChild. Therefore, we need
// to capture the next-in-flow's next sibling (in case the
// next-in-flow is the last next-in-flow for aChild AND the
// next-in-flow is not the last child in parent)
NS_ASSERTION(aChild->GetGeometricParent() == parent, "screwy flow");
NS_ASSERTION(aChild->GetNextSibling() == nextInFlow, "unexpected sibling");
NS_ASSERTION(((nsContainerFrame*)parent)->IsChild(aChild), "screwy flow");
aChild->GetNextSibling(nextSibling);
NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");
aChild->SetNextSibling(nextInFlow->GetNextSibling());
nextInFlow->GetNextSibling(nextSibling);
aChild->SetNextSibling(nextSibling);
}
// Delete the next-in-flow frame and adjust it's parent's child count
@ -548,9 +595,11 @@ PRBool nsContainerFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
if (0 != parent->mChildCount) {
parent->CheckContentOffsets();
}
aChild->GetNextInFlow(nextInFlow);
NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
#endif
NS_POSTCONDITION(nsnull == aChild->GetNextInFlow(), "non null next-in-flow");
return PR_TRUE;
}
@ -605,7 +654,12 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
{
NS_PRECONDITION(nsnull != aFromChild, "null pointer");
NS_PRECONDITION(nsnull != aPrevSibling, "pushing first child");
NS_PRECONDITION(aPrevSibling->GetNextSibling() == aFromChild, "bad prev sibling");
#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);
@ -631,7 +685,7 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
#endif
// Compute the number of children being pushed, and for each child change
// its geometric parent. Remember the last child
for (nsIFrame* f = aFromChild; nsnull != f; f = f->GetNextSibling()) {
for (nsIFrame* f = aFromChild; nsnull != f; f->GetNextSibling(f)) {
numChildren++;
#ifdef NOISY
printf(" ");
@ -640,7 +694,11 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
#endif
lastChild = f;
f->SetGeometricParent(nextInFlow);
if (this == f->GetContentParent()) {
nsIFrame* contentParent;
f->GetContentParent(contentParent);
if (this == contentParent) {
f->SetContentParent(nextInFlow);
}
}
@ -653,14 +711,15 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
// Update our next-in-flow's first content offset and child count
nextInFlow->SetFirstContentOffset(aFromChild);
if (0 == nextInFlow->mChildCount) {
NS_ASSERTION(nextInFlow->LastChild() == lastChild, "unexpected last child");
nextInFlow->SetLastContentOffset(lastChild);
// If the child is pseudo-frame then SetLastContentOffset will
// have updated the next-in-flow's mLastContentIsComplete flag,
// otherwise we have to do it.
if (!nextInFlow->ChildIsPseudoFrame(lastChild)) {
nextInFlow->mLastContentIsComplete =
PRBool(nsnull == lastChild->GetNextInFlow());
nsIFrame* lastChildNextInFlow;
lastChild->GetNextInFlow(lastChildNextInFlow);
nextInFlow->mLastContentIsComplete = PRBool(nsnull == lastChildNextInFlow);
}
}
nextInFlow->mChildCount += numChildren;
@ -701,12 +760,12 @@ void nsContainerFrame::PushChildren(nsIFrame* aFromChild,
// Note: mLastContentIsComplete is not set correctly by this routine
// (we don't always know the correct value at this time)
nsIFrame* nsContainerFrame::PullUpOneChild(nsContainerFrame* aNextInFlow,
nsIFrame* aLastChild)
nsIFrame* aLastChild)
{
NS_PRECONDITION(nsnull != aNextInFlow, "null ptr");
#ifdef NS_DEBUG
if (nsnull != aLastChild) {
NS_PRECONDITION(nsnull == aLastChild->GetNextSibling(), "bad last child");
NS_PRECONDITION(aNextInFlow->IsLastChild(aLastChild), "bad last child");
}
#endif
@ -727,7 +786,7 @@ nsIFrame* nsContainerFrame::PullUpOneChild(nsContainerFrame* aNextInFlow,
// Take the frame away from the next-in-flow. Update it's first
// content offset and propagate upward the offset if the
// next-in-flow is a pseudo-frame.
aNextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(aNextInFlow->mFirstChild);
aNextInFlow->mChildCount--;
if (nsnull != aNextInFlow->mFirstChild) {
aNextInFlow->SetFirstContentOffset(aNextInFlow->mFirstChild);
@ -743,7 +802,11 @@ nsIFrame* nsContainerFrame::PullUpOneChild(nsContainerFrame* aNextInFlow,
// Now give the frame to this container
kidFrame->SetGeometricParent(this);
if (aNextInFlow == kidFrame->GetContentParent()) {
nsIFrame* contentParent;
kidFrame->GetContentParent(contentParent);
if (aNextInFlow == contentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == aLastChild) {
@ -813,18 +876,26 @@ void nsContainerFrame::AppendChildren(nsIFrame* aChild, PRBool aSetParent)
// We have no children so aChild becomes the first child
mFirstChild = aChild;
} else {
LastChild()->SetNextSibling(aChild);
nsIFrame* lastChild;
LastChild(lastChild);
lastChild->SetNextSibling(aChild);
}
// Update our child count and last content offset
nsIFrame* lastChild;
for (nsIFrame* f = aChild; nsnull != f; f = f->GetNextSibling()) {
for (nsIFrame* f = aChild; nsnull != f; f->GetNextSibling(f)) {
lastChild = f;
mChildCount++;
// Reset the geometric parent if requested
if (aSetParent) {
if (f->GetContentParent() == f->GetGeometricParent()) {
nsIFrame* geometricParent;
nsIFrame* contentParent;
f->GetGeometricParent(geometricParent);
f->GetContentParent(contentParent);
if (contentParent == geometricParent) {
f->SetContentParent(this);
}
f->SetGeometricParent(this);
@ -837,7 +908,10 @@ void nsContainerFrame::AppendChildren(nsIFrame* aChild, PRBool aSetParent)
}
SetLastContentOffset(lastChild);
if (!ChildIsPseudoFrame(lastChild)) {
mLastContentIsComplete = PRBool(nsnull == lastChild->GetNextInFlow());
nsIFrame* nextInFlow;
lastChild->GetNextInFlow(nextInFlow);
mLastContentIsComplete = PRBool(nsnull == nextInFlow);
}
#ifdef NS_DEBUG
@ -883,7 +957,7 @@ void nsContainerFrame::AdjustOffsetOfEmptyNextInFlows()
while (nsnull != nextInFlow) {
if (nsnull == nextInFlow->mFirstChild) {
NS_ASSERTION(0 == nextInFlow->ChildCount(), "bad child count");
NS_ASSERTION(nextInFlow->IsEmpty(), "bad state");
nextInFlow->mFirstContentOffset = nextOffset;
// If the next-in-flow is a pseudo-frame then we need to have it
// update it's parents offsets too.
@ -908,7 +982,7 @@ void nsContainerFrame::AdjustOffsetOfEmptyNextInFlows()
/////////////////////////////////////////////////////////////////////////////
// Debugging
void nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
NS_METHOD nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
{
// Indent
for (PRInt32 i = aIndent; --i >= 0; ) fputs(" ", out);
@ -926,13 +1000,13 @@ void nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
out << mRect;
// Output the children
if (ChildCount() > 0) {
if (mChildCount > 0) {
if (!mLastContentIsComplete) {
fputs(", complete=>false ", out);
}
fputs("<\n", out);
for (nsIFrame* child = FirstChild(); child; child = NextChild(child)) {
for (nsIFrame* child = mFirstChild; child; NextChild(child, child)) {
child->List(out, aIndent + 1);
}
for (PRInt32 i = aIndent; --i >= 0; ) fputs(" ", out);
@ -940,33 +1014,35 @@ void nsContainerFrame::List(FILE* out, PRInt32 aIndent) const
} else {
fputs("<>\n", out);
}
return NS_OK;
}
void nsContainerFrame::ListTag(FILE* out) const
NS_METHOD nsContainerFrame::ListTag(FILE* out) const
{
if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
fputs("*", out);
}
nsFrame::ListTag(out);
return NS_OK;
}
#define VERIFY_ASSERT(_expr, _msg) \
if (!(_expr)) { \
const nsIFrame* top = this; \
while (top->GetGeometricParent() != nsnull) { \
top = top->GetGeometricParent(); \
} \
top->List(); \
DumpTree(); \
} \
NS_ASSERTION(_expr, _msg)
void nsContainerFrame::VerifyTree() const
NS_METHOD nsContainerFrame::VerifyTree() const
{
#ifdef NS_DEBUG
// Check our child count
PRInt32 len = LengthOf(mFirstChild);
VERIFY_ASSERT(len == mChildCount, "bad child count");
nsIFrame* lastChild = LastChild();
nsIFrame* lastChild;
LastChild(lastChild);
if (len != 0) {
VERIFY_ASSERT(nsnull != lastChild, "bad last child");
}
@ -1003,13 +1079,19 @@ void nsContainerFrame::VerifyTree() const
offset++;
}
} else {
VERIFY_ASSERT(offset == child->GetIndexInParent(), "bad child offset");
if (nsnull == child->GetNextInFlow()) {
PRInt32 indexInParent;
child->GetIndexInParent(indexInParent);
VERIFY_ASSERT(offset == indexInParent, "bad child offset");
nsIFrame* nextInFlow;
child->GetNextInFlow(nextInFlow);
if (nsnull == nextInFlow) {
offset++;
}
}
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// Verify that our last content offset is correct
@ -1034,6 +1116,7 @@ void nsContainerFrame::VerifyTree() const
}
}
#endif
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////////
@ -1045,12 +1128,67 @@ PRInt32 nsContainerFrame::LengthOf(nsIFrame* aFrame)
while (nsnull != aFrame) {
result++;
aFrame = aFrame->GetNextSibling();
aFrame->GetNextSibling(aFrame);
}
return result;
}
PRBool nsContainerFrame::IsChild(const nsIFrame* aChild) const
{
// Check the geometric parent
nsIFrame* parent;
aChild->GetGeometricParent(parent);
if (parent != (nsIFrame*)this) {
return PR_FALSE;
}
// Check that aChild is in our sibling list
PRInt32 index;
IndexOf(aChild, index);
if (-1 == index) {
return PR_FALSE;
}
return PR_TRUE;
}
PRBool nsContainerFrame::IsLastChild(const nsIFrame* aChild) const
{
// Check the geometric parent
nsIFrame* parent;
aChild->GetGeometricParent(parent);
if (parent != (nsIFrame*)this) {
return PR_FALSE;
}
// Check that aChild is in our sibling list
nsIFrame* lastChild;
LastChild(lastChild);
if (lastChild != aChild) {
return PR_FALSE;
}
return PR_TRUE;
}
void nsContainerFrame::DumpTree() const
{
nsIFrame* root = (nsIFrame*)this;
nsIFrame* parent = mGeometricParent;
while (nsnull != parent) {
root = parent;
parent->GetGeometricParent(parent);
}
root->List();
}
void nsContainerFrame::CheckContentOffsets()
{
NS_PRECONDITION(nsnull != mFirstChild, "null first child");
@ -1060,30 +1198,25 @@ void nsContainerFrame::CheckContentOffsets()
nsContainerFrame* pseudoFrame = (nsContainerFrame*)mFirstChild;
if (pseudoFrame->GetFirstContentOffset() != mFirstContentOffset) {
nsIFrame* top = this;
while (top->GetGeometricParent() != nsnull) {
top = top->GetGeometricParent();
}
top->List();
DumpTree();
}
NS_ASSERTION(pseudoFrame->GetFirstContentOffset() == mFirstContentOffset,
"bad first content offset");
} else {
#ifdef NS_DEBUG
if (!(mFirstChild->GetIndexInParent() == mFirstContentOffset)) {
nsIFrame* top = this;
while (top->GetGeometricParent() != nsnull) {
top = top->GetGeometricParent();
}
top->List();
PRInt32 indexInParent;
mFirstChild->GetIndexInParent(indexInParent);
if (indexInParent != mFirstContentOffset) {
DumpTree();
}
#endif
NS_ASSERTION(mFirstChild->GetIndexInParent() == mFirstContentOffset,
"bad first content offset");
NS_ASSERTION(indexInParent == mFirstContentOffset, "bad first content offset");
}
// Verify that our last content offset is correct
nsIFrame* lastChild = LastChild();
nsIFrame* lastChild;
LastChild(lastChild);
if (ChildIsPseudoFrame(lastChild)) {
nsContainerFrame* pseudoFrame = (nsContainerFrame*)lastChild;
@ -1091,8 +1224,10 @@ void nsContainerFrame::CheckContentOffsets()
"bad last content offset");
} else {
NS_ASSERTION(lastChild->GetIndexInParent() == mLastContentOffset,
"bad last content offset");
PRInt32 indexInParent;
lastChild->GetIndexInParent(indexInParent);
NS_ASSERTION(indexInParent == mLastContentOffset, "bad last content offset");
}
}
@ -1160,11 +1295,7 @@ void nsContainerFrame::CheckNextInFlowOffsets()
}
#ifdef NS_DEBUG
if (nextInFlow->GetFirstContentOffset() != nextOffset) {
nsIFrame* top = this;
while (top->GetGeometricParent() != nsnull) {
top = top->GetGeometricParent();
}
top->List();
DumpTree();
}
#endif
NS_ASSERTION(nextInFlow->GetFirstContentOffset() == nextOffset,
@ -1193,7 +1324,9 @@ nsContainerFrame::SafeToCheckLastContentOffset(nsContainerFrame* aContainer)
return PR_FALSE;
}
nsIFrame* lastChild = aContainer->LastChild();
nsIFrame* lastChild;
aContainer->LastChild(lastChild);
if (aContainer->ChildIsPseudoFrame(lastChild)) {
// If the containers last child is a pseudo-frame then the
// containers last content offset is determined by the child. Ask
@ -1218,8 +1351,9 @@ void nsContainerFrame::VerifyLastIsComplete() const
return;
}
nsIFrame* lastKid = LastChild();
nsIFrame* lastKid;
LastChild(lastKid);
if (ChildIsPseudoFrame(lastKid)) {
// When my last child is a pseudo-frame it means that our
// mLastContentIsComplete is a copy of it's.
@ -1230,17 +1364,14 @@ void nsContainerFrame::VerifyLastIsComplete() const
// If my last child has a next-in-flow then our
// mLastContentIsComplete must be false (because our last child is
// obviously not complete)
nsIFrame* lastKidNextInFlow = lastKid->GetNextInFlow();
nsIFrame* lastKidNextInFlow;
lastKid->GetNextInFlow(lastKidNextInFlow);
if (nsnull != lastKidNextInFlow) {
if (mLastContentIsComplete) {
const nsIFrame* top = this;
while (top->GetGeometricParent() != nsnull) {
top = top->GetGeometricParent();
}
top->List();
DumpTree();
}
NS_ASSERTION(mLastContentIsComplete == PR_FALSE,
"bad mLastContentIsComplete");
NS_ASSERTION(mLastContentIsComplete == PR_FALSE, "bad mLastContentIsComplete");
} else {
// We don't know what state our mLastContentIsComplete should be in.
}

71
layout/base/src/nsContainerFrame.h
Просмотреть файл

@ -111,62 +111,65 @@ public:
* set the content offsets, mLastContentOffset, and append the continuing
* frame to the flow.
*/
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
// Painting
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/**
* Pass through the event to the correct child frame.
* Return PR_TRUE if the event is consumed.
*/
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent);
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame);
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor);
// Child frame enumeration.
// ChildAt() retruns null if the index is not in the range 0 .. ChildCount() - 1.
// IndexOf() returns -1 if the frame is not in the child list.
virtual PRInt32 ChildCount() const;
virtual nsIFrame* ChildAt(PRInt32 aIndex) const;
virtual PRInt32 IndexOf(const nsIFrame* aChild) const;
virtual nsIFrame* FirstChild() const;
virtual nsIFrame* NextChild(const nsIFrame* aChild) const;
virtual nsIFrame* PrevChild(const nsIFrame* aChild) const;
virtual nsIFrame* LastChild() const;
NS_IMETHOD ChildCount(PRInt32& aChildCount) const;
NS_IMETHOD ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const;
NS_IMETHOD IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const;
NS_IMETHOD FirstChild(nsIFrame*& aFirstChild) const;
NS_IMETHOD NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const;
NS_IMETHOD PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const;
NS_IMETHOD LastChild(nsIFrame*& aLastChild) const;
// Access functions for starting and end content offsets. These reflect the
// range of content mapped by the frame.
//
// If the container is empty (has no children) the last content offset is
// undefined
PRInt32 GetFirstContentOffset() const {return mFirstContentOffset;}
void SetFirstContentOffset(PRInt32 aOffset) {mFirstContentOffset = aOffset;}
PRInt32 GetLastContentOffset() const {return mLastContentOffset;}
void SetLastContentOffset(PRInt32 aOffset) {mLastContentOffset = aOffset;}
PRInt32 GetFirstContentOffset() const {return mFirstContentOffset;}
void SetFirstContentOffset(PRInt32 aOffset) {mFirstContentOffset = aOffset;}
PRInt32 GetLastContentOffset() const {return mLastContentOffset;}
void SetLastContentOffset(PRInt32 aOffset) {mLastContentOffset = aOffset;}
/** return PR_TRUE if the last mapped child is complete */
PRBool GetLastContentIsComplete() const {return mLastContentIsComplete;}
PRBool GetLastContentIsComplete() const {return mLastContentIsComplete;}
/** set the state indicating whether the last mapped child is complete */
void SetLastContentIsComplete(PRBool aLIC) {mLastContentIsComplete = aLIC;}
void SetLastContentIsComplete(PRBool aLIC) {mLastContentIsComplete = aLIC;}
// Get the offset for the next child content, i.e. the child after the
// last child that fit in us
PRInt32 NextChildOffset() const;
PRInt32 NextChildOffset() const;
// Returns true if this frame is being used a pseudo frame
PRBool IsPseudoFrame() const;
PRBool IsPseudoFrame() const;
// Debugging
virtual void List(FILE* out = stdout, PRInt32 aIndent = 0) const;
virtual void ListTag(FILE* out = stdout) const;
virtual void VerifyTree() const;
NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const;
NS_IMETHOD ListTag(FILE* out = stdout) const;
NS_IMETHOD VerifyTree() const;
/**
* This is used to propagate this frame's mFirstContentOffset, mLastContentOffset,
@ -342,6 +345,18 @@ protected:
*/
static PRInt32 LengthOf(nsIFrame* aChild);
/**
* Returns PR_TRUE if aChild is a child of this frame.
*/
PRBool IsChild(const nsIFrame* aChild) const;
/**
* Returns PR_TRUE if aChild is the last child of this frame.
*/
PRBool IsLastChild(const nsIFrame* aChild) const;
void DumpTree() const;
/**
* Before reflow for this container has started we check that all
* is well.

370
layout/base/src/nsFrame.cpp
Просмотреть файл

@ -119,19 +119,21 @@ nsrefcnt nsFrame::Release(void)
/////////////////////////////////////////////////////////////////////////////
// nsIFrame
void nsFrame::DeleteFrame()
NS_METHOD nsFrame::DeleteFrame()
{
nsIView* view = mView;
if (nsnull == view) {
nsIFrame* parent = GetParentWithView();
nsIFrame* parent;
GetParentWithView(parent);
if (nsnull != parent) {
view = parent->GetView();
parent->GetView(view);
}
}
if (nsnull != view) {
nsIViewManager* vm = view->GetViewManager();
nsIPresContext* cx = vm->GetPresContext();
//is this a really good ordering for the releases? MMP
// XXX Is this a really good ordering for the releases? MMP
NS_RELEASE(vm);
NS_RELEASE(view);
cx->StopLoadImage(this);
@ -139,36 +141,42 @@ void nsFrame::DeleteFrame()
}
delete this;
return NS_OK;
}
nsIContent* nsFrame::GetContent() const
NS_METHOD nsFrame::GetContent(nsIContent*& aContent) const
{
if (nsnull != mContent) {
NS_ADDREF(mContent);
}
return mContent;
aContent = mContent;
return NS_OK;
}
PRInt32 nsFrame::GetIndexInParent() const
NS_METHOD nsFrame::GetIndexInParent(PRInt32& aIndexInParent) const
{
return mIndexInParent;
aIndexInParent = mIndexInParent;
return NS_OK;
}
void nsFrame::SetIndexInParent(PRInt32 aIndexInParent)
NS_METHOD nsFrame::SetIndexInParent(PRInt32 aIndexInParent)
{
mIndexInParent = aIndexInParent;
return NS_OK;
}
nsIStyleContext* nsFrame::GetStyleContext(nsIPresContext* aPresContext)
NS_METHOD nsFrame::GetStyleContext(nsIPresContext* aPresContext,
nsIStyleContext*& aStyleContext)
{
if (nsnull == mStyleContext) {
mStyleContext = aPresContext->ResolveStyleContextFor(mContent, mGeometricParent); // XXX should be content parent???
}
NS_IF_ADDREF(mStyleContext);
return mStyleContext;
aStyleContext = mStyleContext;
return NS_OK;
}
void nsFrame::SetStyleContext(nsIStyleContext* aContext)
NS_METHOD nsFrame::SetStyleContext(nsIStyleContext* aContext)
{
NS_PRECONDITION(nsnull != aContext, "null ptr");
if (aContext != mStyleContext) {
@ -178,65 +186,77 @@ void nsFrame::SetStyleContext(nsIStyleContext* aContext)
NS_ADDREF(aContext);
}
}
return NS_OK;
}
NS_METHOD nsFrame::GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct)
{
NS_ASSERTION(mStyleContext!=nsnull,"null style context");
if (mStyleContext) {
aStyleStruct = mStyleContext->GetData(aSID);
} else {
aStyleStruct = nsnull;
}
return NS_OK;
}
// Geometric and content parent member functions
nsIFrame* nsFrame::GetContentParent() const
NS_METHOD nsFrame::GetContentParent(nsIFrame*& aParent) const
{
return mContentParent;
aParent = mContentParent;
return NS_OK;
}
void nsFrame::SetContentParent(const nsIFrame* aParent)
NS_METHOD nsFrame::SetContentParent(const nsIFrame* aParent)
{
mContentParent = (nsIFrame*)aParent;
return NS_OK;
}
nsIFrame* nsFrame::GetGeometricParent() const
NS_METHOD nsFrame::GetGeometricParent(nsIFrame*& aParent) const
{
return mGeometricParent;
aParent = mGeometricParent;
return NS_OK;
}
void nsFrame::SetGeometricParent(const nsIFrame* aParent)
NS_METHOD nsFrame::SetGeometricParent(const nsIFrame* aParent)
{
mGeometricParent = (nsIFrame*)aParent;
return NS_OK;
}
// Bounding rect member functions
nsRect nsFrame::GetRect() const
{
return mRect;
}
void nsFrame::GetRect(nsRect& aRect) const
NS_METHOD nsFrame::GetRect(nsRect& aRect) const
{
aRect = mRect;
return NS_OK;
}
void nsFrame::GetOrigin(nsPoint& aPoint) const
NS_METHOD nsFrame::GetOrigin(nsPoint& aPoint) const
{
aPoint.x = mRect.x;
aPoint.y = mRect.y;
return NS_OK;
}
nscoord nsFrame::GetWidth() const
NS_METHOD nsFrame::GetSize(nsSize& aSize) const
{
return mRect.width;
aSize.width = mRect.width;
aSize.height = mRect.height;
return NS_OK;
}
nscoord nsFrame::GetHeight() const
{
return mRect.height;
}
void nsFrame::SetRect(const nsRect& aRect)
NS_METHOD nsFrame::SetRect(const nsRect& aRect)
{
MoveTo(aRect.x, aRect.y);
SizeTo(aRect.width, aRect.height);
return NS_OK;
}
void nsFrame::MoveTo(nscoord aX, nscoord aY)
NS_METHOD nsFrame::MoveTo(nscoord aX, nscoord aY)
{
if ((aX != mRect.x) || (aY != mRect.y)) {
mRect.x = aX;
@ -247,9 +267,11 @@ void nsFrame::MoveTo(nscoord aX, nscoord aY)
mView->SetPosition(aX, aY);
}
}
return NS_OK;
}
void nsFrame::SizeTo(nscoord aWidth, nscoord aHeight)
NS_METHOD nsFrame::SizeTo(nscoord aWidth, nscoord aHeight)
{
if ((aWidth != mRect.width) || (aHeight != mRect.height)) {
mRect.width = aWidth;
@ -260,76 +282,89 @@ void nsFrame::SizeTo(nscoord aWidth, nscoord aHeight)
mView->SetDimensions(aWidth, aHeight);
}
}
return NS_OK;
}
// Child frame enumeration
PRInt32 nsFrame::ChildCount() const
NS_METHOD nsFrame::ChildCount(PRInt32& aChildCount) const
{
return 0;
aChildCount = 0;
return NS_OK;
}
nsIFrame* nsFrame::ChildAt(PRInt32 aIndex) const
NS_METHOD nsFrame::ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const
{
NS_ERROR("not a container");
return nsnull;
aFrame = nsnull;
return NS_OK;
}
PRInt32 nsFrame::IndexOf(const nsIFrame* aChild) const
NS_METHOD nsFrame::IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const
{
NS_ERROR("not a container");
return -1;
aIndex = -1;
return NS_OK;
}
nsIFrame* nsFrame::FirstChild() const
NS_METHOD nsFrame::FirstChild(nsIFrame*& aFirstChild) const
{
return nsnull;
aFirstChild = nsnull;
return NS_OK;
}
nsIFrame* nsFrame::NextChild(const nsIFrame* aChild) const
NS_METHOD nsFrame::NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const
{
NS_ERROR("not a container");
return nsnull;
aNextChild = nsnull;
return NS_OK;
}
nsIFrame* nsFrame::PrevChild(const nsIFrame* aChild) const
NS_METHOD nsFrame::PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const
{
NS_ERROR("not a container");
return nsnull;
aPrevChild = nsnull;
return NS_OK;
}
nsIFrame* nsFrame::LastChild() const
NS_METHOD nsFrame::LastChild(nsIFrame*& aLastChild) const
{
return nsnull;
aLastChild = nsnull;
return NS_OK;
}
void nsFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
return NS_OK;
}
nsEventStatus nsFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent)
NS_METHOD nsFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
nsEventStatus retval = nsEventStatus_eIgnore;
return retval;
aEventStatus = nsEventStatus_eIgnore;
return NS_OK;
}
PRInt32 nsFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame)
NS_METHOD nsFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor)
{
return NS_STYLE_CURSOR_INHERIT;
aCursor = NS_STYLE_CURSOR_INHERIT;
return NS_OK;
}
// Resize and incremental reflow
nsIFrame::ReflowStatus
nsFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
aDesiredSize.width = 0;
aDesiredSize.height = 0;
@ -339,136 +374,156 @@ nsFrame::ResizeReflow(nsIPresContext* aPresContext,
aMaxElementSize->width = 0;
aMaxElementSize->height = 0;
}
return frComplete;
aStatus = frComplete;
return NS_OK;
}
void
nsFrame::JustifyReflow(nsIPresContext* aPresContext,
nscoord aAvailableSpace)
NS_METHOD nsFrame::JustifyReflow(nsIPresContext* aPresContext,
nscoord aAvailableSpace)
{
return NS_OK;
}
nsIFrame::ReflowStatus
nsFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
NS_ERROR("not a reflow command handler");
aDesiredSize.width = 0;
aDesiredSize.height = 0;
aDesiredSize.ascent = 0;
aDesiredSize.descent = 0;
return frComplete;
aStatus = frComplete;
return NS_OK;
}
void nsFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
return NS_OK;
}
void nsFrame::ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent)
NS_METHOD nsFrame::ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent)
{
return NS_OK;
}
void nsFrame::ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent)
NS_METHOD nsFrame::ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent)
{
return NS_OK;
}
void nsFrame::ContentDeleted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent)
NS_METHOD nsFrame::ContentDeleted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent)
{
return NS_OK;
}
void nsFrame::GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics)
NS_METHOD nsFrame::GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics)
{
aMetrics.width = mRect.width;
aMetrics.height = mRect.height;
aMetrics.ascent = mRect.height;
aMetrics.descent = 0;
return NS_OK;
}
// Flow member functions
PRBool nsFrame::IsSplittable() const
NS_METHOD nsFrame::IsSplittable(PRBool& aIsSplittable) const
{
return PR_FALSE;
aIsSplittable = PR_FALSE;
return NS_OK;
}
nsIFrame* nsFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
NS_ERROR("not splittable");
return nsnull;
aContinuingFrame = nsnull;
return NS_OK;
}
nsIFrame* nsFrame::GetPrevInFlow() const
NS_METHOD nsFrame::GetPrevInFlow(nsIFrame*& aPrevInFlow) const
{
return nsnull;
aPrevInFlow = nsnull;
return NS_OK;
}
void nsFrame::SetPrevInFlow(nsIFrame*)
NS_METHOD nsFrame::SetPrevInFlow(nsIFrame*)
{
NS_ERROR("not splittable");
return NS_OK;
}
nsIFrame* nsFrame::GetNextInFlow() const
NS_METHOD nsFrame::GetNextInFlow(nsIFrame*& aNextInFlow) const
{
return nsnull;
aNextInFlow = nsnull;
return NS_OK;
}
void nsFrame::SetNextInFlow(nsIFrame*)
NS_METHOD nsFrame::SetNextInFlow(nsIFrame*)
{
NS_ERROR("not splittable");
return NS_OK;
}
void nsFrame::AppendToFlow(nsIFrame* aAfterFrame)
NS_METHOD nsFrame::AppendToFlow(nsIFrame* aAfterFrame)
{
NS_ERROR("not splittable");
return NS_OK;
}
void nsFrame::PrependToFlow(nsIFrame* aBeforeFrame)
NS_METHOD nsFrame::PrependToFlow(nsIFrame* aBeforeFrame)
{
NS_ERROR("not splittable");
return NS_OK;
}
void nsFrame::RemoveFromFlow()
NS_METHOD nsFrame::RemoveFromFlow()
{
NS_ERROR("not splittable");
return NS_OK;
}
void nsFrame::BreakFromPrevFlow()
NS_METHOD nsFrame::BreakFromPrevFlow()
{
NS_ERROR("not splittable");
return NS_OK;
}
void nsFrame::BreakFromNextFlow()
NS_METHOD nsFrame::BreakFromNextFlow()
{
NS_ERROR("not splittable");
return NS_OK;
}
// Associated view object
nsIView* nsFrame::GetView() const
NS_METHOD nsFrame::GetView(nsIView*& aView) const
{
NS_IF_ADDREF(mView);
return mView;
aView = mView;
NS_IF_ADDREF(aView);
return NS_OK;
}
void nsFrame::SetView(nsIView* aView)
NS_METHOD nsFrame::SetView(nsIView* aView)
{
NS_IF_RELEASE(mView);
if (nsnull != aView) {
@ -476,78 +531,88 @@ void nsFrame::SetView(nsIView* aView)
aView->SetFrame(this);
NS_ADDREF(aView);
}
return NS_OK;
}
// Find the first geometric parent that has a view
nsIFrame* nsFrame::GetParentWithView() const
NS_METHOD nsFrame::GetParentWithView(nsIFrame*& aParent) const
{
nsIFrame* parent = mGeometricParent;
aParent = mGeometricParent;
while (nsnull != parent) {
nsIView* parView = parent->GetView();
while (nsnull != aParent) {
nsIView* parView;
aParent->GetView(parView);
if (nsnull != parView) {
NS_RELEASE(parView);
break;
}
parent = parent->GetGeometricParent();
aParent->GetGeometricParent(aParent);
}
return parent;
return NS_OK;
}
// Returns the offset from this frame to the closest geometric parent that
// has a view. Also returns the containing view or null in case of error
nsIView* nsFrame::GetOffsetFromView(nsPoint& aOffset) const
NS_METHOD nsFrame::GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const
{
const nsIFrame* frame = this;
nsIView* result = nsnull;
nsPoint origin;
nsIFrame* frame = (nsIFrame*)this;
aView = nsnull;
aOffset.MoveTo(0, 0);
nsIView* view = nsnull;
do {
nsPoint origin;
frame->GetOrigin(origin);
aOffset += origin;
frame = frame->GetGeometricParent();
view = (frame == nsnull) ? nsnull : frame->GetView();
} while ((nsnull != frame) && (nsnull == view));
frame->GetGeometricParent(frame);
if (nsnull != frame) {
frame->GetView(aView);
}
} while ((nsnull != frame) && (nsnull == aView));
return view;
return NS_OK;
}
nsIWidget* nsFrame::GetWindow() const
NS_METHOD nsFrame::GetWindow(nsIWidget*& aWindow) const
{
nsIWidget* window = nsnull;
const nsIFrame* frame = this;
nsIFrame* frame = (nsIFrame*)this;
aWindow = nsnull;
while (nsnull != frame) {
nsIView* view = frame->GetView();
nsIView* view;
frame->GetView(view);
if (nsnull != view) {
window = view->GetWidget();
aWindow = view->GetWidget();
NS_RELEASE(view);
if (nsnull != window) {
return window;
if (nsnull != aWindow) {
break;
}
}
frame = frame->GetParentWithView();
frame->GetParentWithView(frame);
}
NS_POSTCONDITION(nsnull != window, "no window in frame tree");
return nsnull;
NS_POSTCONDITION(nsnull != aWindow, "no window in frame tree");
return NS_OK;
}
// Sibling pointer used to link together frames
nsIFrame* nsFrame::GetNextSibling() const
NS_METHOD nsFrame::GetNextSibling(nsIFrame*& aNextSibling) const
{
return mNextSibling;
aNextSibling = mNextSibling;
return NS_OK;
}
void nsFrame::SetNextSibling(nsIFrame* aNextSibling)
NS_METHOD nsFrame::SetNextSibling(nsIFrame* aNextSibling)
{
mNextSibling = aNextSibling;
return NS_OK;
}
// Debugging
void nsFrame::List(FILE* out, PRInt32 aIndent) const
NS_METHOD nsFrame::List(FILE* out, PRInt32 aIndent) const
{
// Indent
for (PRInt32 i = aIndent; --i >= 0; ) fputs(" ", out);
@ -557,10 +622,11 @@ void nsFrame::List(FILE* out, PRInt32 aIndent) const
fputs(" ", out);
out << mRect;
fputs("<>\n", out);
return NS_OK;
}
// Output the frame's tag
void nsFrame::ListTag(FILE* out) const
NS_METHOD nsFrame::ListTag(FILE* out) const
{
nsIAtom* tag = mContent->GetTag();
if (tag != nsnull) {
@ -570,16 +636,10 @@ void nsFrame::ListTag(FILE* out) const
NS_RELEASE(tag);
}
fprintf(out, "(%d)@%p", mIndexInParent, this);
return NS_OK;
}
void nsFrame::VerifyTree() const
NS_METHOD nsFrame::VerifyTree() const
{
}
nsStyleStruct* nsFrame::GetStyleData(const nsIID& aSID)
{
NS_ASSERTION(mStyleContext!=nsnull,"null style context");
if (mStyleContext)
return mStyleContext->GetData(aSID);
return nsnull;
return NS_OK;
}

186
layout/base/src/nsFrame.h
Просмотреть файл

@ -35,133 +35,139 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
// Overloaded new operator. Initializes the memory to 0
void* operator new(size_t size);
virtual void DeleteFrame();
NS_IMETHOD DeleteFrame();
virtual nsIContent* GetContent() const;
virtual PRInt32 GetIndexInParent() const;
virtual void SetIndexInParent(PRInt32 aIndexInParent);
NS_IMETHOD GetContent(nsIContent*& aContent) const;
NS_IMETHOD GetIndexInParent(PRInt32& aIndexInParent) const;
NS_IMETHOD SetIndexInParent(PRInt32 aIndexInParent);
NS_IMETHOD GetStyleContext(nsIPresContext* aContext, nsIStyleContext*& aStyleContext);
NS_IMETHOD SetStyleContext(nsIStyleContext* aContext);
// Get the style struct associated with this frame
NS_IMETHOD GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct);
virtual nsIStyleContext* GetStyleContext(nsIPresContext* aContext);
virtual void SetStyleContext(nsIStyleContext* aContext);
// Geometric and content parent
virtual nsIFrame* GetContentParent() const;
virtual void SetContentParent(const nsIFrame* aParent);
virtual nsIFrame* GetGeometricParent() const;
virtual void SetGeometricParent(const nsIFrame* aParent);
NS_IMETHOD GetContentParent(nsIFrame*& aParent) const;
NS_IMETHOD SetContentParent(const nsIFrame* aParent);
NS_IMETHOD GetGeometricParent(nsIFrame*& aParent) const;
NS_IMETHOD SetGeometricParent(const nsIFrame* aParent);
// Bounding rect
virtual nsRect GetRect() const;
virtual void GetRect(nsRect& aRect) const;
virtual void GetOrigin(nsPoint& aPoint) const;
virtual nscoord GetWidth() const;
virtual nscoord GetHeight() const;
virtual void SetRect(const nsRect& aRect);
virtual void MoveTo(nscoord aX, nscoord aY);
virtual void SizeTo(nscoord aWidth, nscoord aHeight);
NS_IMETHOD GetRect(nsRect& aRect) const;
NS_IMETHOD GetOrigin(nsPoint& aPoint) const;
NS_IMETHOD GetSize(nsSize& aSize) const;
NS_IMETHOD SetRect(const nsRect& aRect);
NS_IMETHOD MoveTo(nscoord aX, nscoord aY);
NS_IMETHOD SizeTo(nscoord aWidth, nscoord aHeight);
// Child frame enumeration
virtual PRInt32 ChildCount() const;
virtual nsIFrame* ChildAt(PRInt32 aIndex) const;
virtual PRInt32 IndexOf(const nsIFrame* aChild) const;
virtual nsIFrame* FirstChild() const;
virtual nsIFrame* NextChild(const nsIFrame* aChild) const;
virtual nsIFrame* PrevChild(const nsIFrame* aChild) const;
virtual nsIFrame* LastChild() const;
NS_IMETHOD ChildCount(PRInt32& aChildCount) const;
NS_IMETHOD ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const;
NS_IMETHOD IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const;
NS_IMETHOD FirstChild(nsIFrame*& aFirstChild) const;
NS_IMETHOD NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const;
NS_IMETHOD PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const;
NS_IMETHOD LastChild(nsIFrame*& aLastChild) const;
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent);
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame);
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor);
// Resize reflow methods
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
virtual void JustifyReflow(nsIPresContext* aCX,
nscoord aAvailableSpace);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
NS_IMETHOD JustifyReflow(nsIPresContext* aPresContext,
nscoord aAvailableSpace);
// Incremental reflow methods
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
virtual void ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent);
virtual void ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent);
virtual void ContentDeleted(nsIPresShell* aShell,
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent);
virtual void GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
nsIContent* aContainer);
NS_IMETHOD ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent);
NS_IMETHOD ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent);
NS_IMETHOD ContentDeleted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent);
NS_IMETHOD GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
// Flow member functions
virtual PRBool IsSplittable() const;
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
virtual nsIFrame* GetPrevInFlow() const;
virtual void SetPrevInFlow(nsIFrame*);
virtual nsIFrame* GetNextInFlow() const;
virtual void SetNextInFlow(nsIFrame*);
NS_IMETHOD IsSplittable(PRBool& aIsSplittable) const;
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
virtual void AppendToFlow(nsIFrame* aAfterFrame);
virtual void PrependToFlow(nsIFrame* aAfterFrame);
virtual void RemoveFromFlow();
virtual void BreakFromPrevFlow();
virtual void BreakFromNextFlow();
NS_IMETHOD GetPrevInFlow(nsIFrame*& aPrevInFlow) const;
NS_IMETHOD SetPrevInFlow(nsIFrame*);
NS_IMETHOD GetNextInFlow(nsIFrame*& aNextInFlow) const;
NS_IMETHOD SetNextInFlow(nsIFrame*);
NS_IMETHOD AppendToFlow(nsIFrame* aAfterFrame);
NS_IMETHOD PrependToFlow(nsIFrame* aAfterFrame);
NS_IMETHOD RemoveFromFlow();
NS_IMETHOD BreakFromPrevFlow();
NS_IMETHOD BreakFromNextFlow();
// Associated view object
virtual nsIView* GetView() const;
virtual void SetView(nsIView* aView);
NS_IMETHOD GetView(nsIView*& aView) const;
NS_IMETHOD SetView(nsIView* aView);
// Find the first geometric parent that has a view
virtual nsIFrame* GetParentWithView() const;
NS_IMETHOD GetParentWithView(nsIFrame*& aParent) const;
// Returns the offset from this frame to the closest geometric parent that
// has a view. Also returns the containing view, or null in case of error
virtual nsIView* GetOffsetFromView(nsPoint& aOffset) const;
NS_IMETHOD GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const;
// Returns the closest geometric parent that has a view which has a
// a window.
virtual nsIWidget* GetWindow() const;
NS_IMETHOD GetWindow(nsIWidget*&) const;
// Sibling pointer used to link together frames
virtual nsIFrame* GetNextSibling() const;
virtual void SetNextSibling(nsIFrame* aNextSibling);
NS_IMETHOD GetNextSibling(nsIFrame*& aNextSibling) const;
NS_IMETHOD SetNextSibling(nsIFrame* aNextSibling);
// Debugging
virtual void List(FILE* out = stdout, PRInt32 aIndent = 0) const;
virtual void ListTag(FILE* out = stdout) const;
virtual void VerifyTree() const;
// Get the style struct associated with this frame
virtual nsStyleStruct* GetStyleData(const nsIID& aSID);
NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const;
NS_IMETHOD ListTag(FILE* out = stdout) const;
NS_IMETHOD VerifyTree() const;
protected:
// Constructor. Takes as arguments the content object, the index in parent,

12
layout/base/src/nsPresContext.cpp
Просмотреть файл

@ -190,7 +190,9 @@ void ImageLoader::UpdateFrames()
nsIFrame* frame = (nsIFrame*) mFrames.ElementAt(i);
// XXX installed colormap should be presentation-context/window state
nsIWidget* window = frame->GetWindow();
nsIWidget* window;
frame->GetWindow(window);
if (!gXXXInstalledColorMap && mImage) {
nsColorMap* cmap = mImage->GetColorMap();
if ((nsnull != cmap) && (cmap->NumColors > 0)) {
@ -203,7 +205,9 @@ void ImageLoader::UpdateFrames()
nsPoint offset;
nsRect bounds;
frame->GetRect(bounds);
nsIView* view = frame->GetOffsetFromView(offset);
nsIView* view;
frame->GetOffsetFromView(offset, view);
nsIViewManager* vm = view->GetViewManager();
bounds.x = offset.x;
bounds.y = offset.y;
@ -360,7 +364,9 @@ nsIImage* nsPresContext::LoadImage(const nsString& aURL, nsIFrame* aForFrame)
if (nsnull == mImageGroup) {
// XXX this is bad; if we allow for subwindows that have different
// rendering context's this won't work
nsIWidget* window = aForFrame->GetWindow();
nsIWidget* window;
aForFrame->GetWindow(window);
nsIRenderingContext* drawCtx = window->GetRenderingContext();
drawCtx->Scale(mDeviceContext->GetAppUnitsToDevUnits(),
mDeviceContext->GetAppUnitsToDevUnits());

16
layout/base/src/nsPresShell.cpp
Просмотреть файл

@ -368,7 +368,9 @@ void PresShell::ResizeReflow(nscoord aWidth, nscoord aHeight)
#ifdef NS_DEBUG
mRootFrame->VerifyTree();
#endif
mRootFrame->ResizeReflow(mPresContext, desiredSize, maxSize, nsnull);
nsIFrame::ReflowStatus status;
mRootFrame->ResizeReflow(mPresContext, desiredSize, maxSize, nsnull, status);
mRootFrame->SizeTo(desiredSize.width, desiredSize.height);
#ifdef NS_DEBUG
mRootFrame->VerifyTree();
@ -450,7 +452,9 @@ void PresShell::ProcessReflowCommands()
mReflowCommands.RemoveElementAt(0);
// Dispatch the reflow command
nsSize maxSize(mRootFrame->GetWidth(), mRootFrame->GetHeight());
nsSize maxSize;
mRootFrame->GetSize(maxSize);
rc->Dispatch(desiredSize, maxSize);
delete rc;
}
@ -536,14 +540,16 @@ void PresShell::StyleSheetAdded(nsIStyleSheet* aStyleSheet)
static nsIFrame* FindFrameWithContent(nsIFrame* aFrame, nsIContent* aContent)
{
nsIContent* frameContent = aFrame->GetContent();
nsIContent* frameContent;
aFrame->GetContent(frameContent);
if (frameContent == aContent) {
NS_RELEASE(frameContent);
return aFrame;
}
NS_RELEASE(frameContent);
aFrame = aFrame->FirstChild();
aFrame->FirstChild(aFrame);
while (aFrame) {
nsIFrame* result = FindFrameWithContent(aFrame, aContent);
@ -551,7 +557,7 @@ static nsIFrame* FindFrameWithContent(nsIFrame* aFrame, nsIContent* aContent)
return result;
}
aFrame = aFrame->GetNextSibling();
aFrame->GetNextSibling(aFrame);
}
return nsnull;

17
layout/base/src/nsReflowCommand.cpp
Просмотреть файл

@ -143,7 +143,7 @@ void nsReflowCommand::Dispatch(nsReflowMetrics& aDesiredSize,
// Build the path from the target frame (index 0) to the root frame
mPath.Clear();
for (nsIFrame* f = (nsIFrame*)mTargetFrame; nsnull != f;
f = f->GetGeometricParent()) {
f->GetGeometricParent(f)) {
mPath.AppendElement((void*)f);
}
@ -160,7 +160,10 @@ void nsReflowCommand::Dispatch(nsReflowMetrics& aDesiredSize,
if (nsnull != root) {
mPath.RemoveElementAt(mPath.Count() - 1);
root->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize, *this);
nsIFrame::ReflowStatus status;
root->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize, *this, status);
}
}
@ -178,8 +181,8 @@ nsIFrame::ReflowStatus nsReflowCommand::Next(nsReflowMetrics& aDesiredSize,
NS_ASSERTION(nsnull != aNextFrame, "null frame");
mPath.RemoveElementAt(count - 1);
result = aNextFrame->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize,
*this);
aNextFrame->IncrementalReflow(mPresContext, aDesiredSize, aMaxSize,
*this, result);
} else {
aNextFrame = nsnull;
}
@ -209,12 +212,12 @@ nsIFrame::ReflowStatus nsReflowCommand::Next(nsISpaceManager* aSpaceManager,
if (NS_OK == aNextFrame->QueryInterface(kIRunaroundIID, (void**)&reflowRunaround)) {
reflowRunaround->IncrementalReflow(mPresContext, aSpaceManager, aMaxSize,
aDesiredRect, *this);
aDesiredRect, *this, result);
} else {
nsReflowMetrics desiredSize;
result = aNextFrame->IncrementalReflow(mPresContext, desiredSize, aMaxSize,
*this);
aNextFrame->IncrementalReflow(mPresContext, desiredSize, aMaxSize,
*this, result);
aDesiredRect.x = 0;
aDesiredRect.y = 0;
aDesiredRect.width = desiredSize.width;

56
layout/base/src/nsSplittableFrame.cpp
Просмотреть файл

@ -35,9 +35,10 @@ nsSplittableFrame::~nsSplittableFrame()
// Flow member functions
PRBool nsSplittableFrame::IsSplittable() const
NS_METHOD nsSplittableFrame::IsSplittable(PRBool& aIsSplittable) const
{
return PR_TRUE;
aIsSplittable = PR_TRUE;
return NS_OK;
}
/**
@ -48,44 +49,50 @@ PRBool nsSplittableFrame::IsSplittable() const
* the receiver's geometric parent
* @return the continuing frame or null if unsuccessful
*/
nsIFrame* nsSplittableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsSplittableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsIContentDelegate* contentDelegate = mContent->GetDelegate(aPresContext);
nsIFrame* continuingFrame =
contentDelegate->CreateFrame(aPresContext, mContent, mIndexInParent, aParent);
aContinuingFrame = contentDelegate->CreateFrame(aPresContext, mContent,
mIndexInParent, aParent);
NS_RELEASE(contentDelegate);
// Append the continuing frame to the flow
continuingFrame->AppendToFlow(this);
aContinuingFrame->AppendToFlow(this);
// Resolve style for the continuing frame and set its style context.
nsIStyleContext* styleContext =
aPresContext->ResolveStyleContextFor(mContent, aParent);
continuingFrame->SetStyleContext(styleContext);
aContinuingFrame->SetStyleContext(styleContext);
NS_RELEASE(styleContext);
return continuingFrame;
return NS_OK;
}
nsIFrame* nsSplittableFrame::GetPrevInFlow() const
NS_METHOD nsSplittableFrame::GetPrevInFlow(nsIFrame*& aPrevInFlow) const
{
return mPrevInFlow;
aPrevInFlow = mPrevInFlow;
return NS_OK;
}
void nsSplittableFrame::SetPrevInFlow(nsIFrame* aFrame)
NS_METHOD nsSplittableFrame::SetPrevInFlow(nsIFrame* aFrame)
{
mPrevInFlow = aFrame;
return NS_OK;
}
nsIFrame* nsSplittableFrame::GetNextInFlow() const
NS_METHOD nsSplittableFrame::GetNextInFlow(nsIFrame*& aNextInFlow) const
{
return mNextInFlow;
aNextInFlow = mNextInFlow;
return NS_OK;
}
void nsSplittableFrame::SetNextInFlow(nsIFrame* aFrame)
NS_METHOD nsSplittableFrame::SetNextInFlow(nsIFrame* aFrame)
{
mNextInFlow = aFrame;
return NS_OK;
}
nsIFrame* nsSplittableFrame::GetFirstInFlow() const
@ -113,33 +120,35 @@ nsIFrame* nsSplittableFrame::GetLastInFlow() const
}
// Append this frame to flow after aAfterFrame
void nsSplittableFrame::AppendToFlow(nsIFrame* aAfterFrame)
NS_METHOD nsSplittableFrame::AppendToFlow(nsIFrame* aAfterFrame)
{
NS_PRECONDITION(aAfterFrame != nsnull, "null pointer");
mPrevInFlow = aAfterFrame;
mNextInFlow = aAfterFrame->GetNextInFlow();
aAfterFrame->GetNextInFlow(mNextInFlow);
mPrevInFlow->SetNextInFlow(this);
if (mNextInFlow) {
mNextInFlow->SetPrevInFlow(this);
}
return NS_OK;
}
// Prepend this frame to flow before aBeforeFrame
void nsSplittableFrame::PrependToFlow(nsIFrame* aBeforeFrame)
NS_METHOD nsSplittableFrame::PrependToFlow(nsIFrame* aBeforeFrame)
{
NS_PRECONDITION(aBeforeFrame != nsnull, "null pointer");
mPrevInFlow = aBeforeFrame->GetPrevInFlow();
aBeforeFrame->GetPrevInFlow(mPrevInFlow);
mNextInFlow = aBeforeFrame;
mNextInFlow->SetPrevInFlow(this);
if (mPrevInFlow) {
mPrevInFlow->SetNextInFlow(this);
}
return NS_OK;
}
// Remove this frame from the flow. Connects prev in flow and next in flow
void nsSplittableFrame::RemoveFromFlow()
NS_METHOD nsSplittableFrame::RemoveFromFlow()
{
if (mPrevInFlow) {
mPrevInFlow->SetNextInFlow(mNextInFlow);
@ -150,23 +159,26 @@ void nsSplittableFrame::RemoveFromFlow()
}
mPrevInFlow = mNextInFlow = nsnull;
return NS_OK;
}
// Detach from previous frame in flow
void nsSplittableFrame::BreakFromPrevFlow()
NS_METHOD nsSplittableFrame::BreakFromPrevFlow()
{
if (mPrevInFlow) {
mPrevInFlow->SetNextInFlow(nsnull);
mPrevInFlow = nsnull;
}
return NS_OK;
}
// Detach from next frame in flow
void nsSplittableFrame::BreakFromNextFlow()
NS_METHOD nsSplittableFrame::BreakFromNextFlow()
{
if (mNextInFlow) {
mNextInFlow->SetPrevInFlow(nsnull);
mNextInFlow = nsnull;
}
return NS_OK;
}

26
layout/base/src/nsSplittableFrame.h
Просмотреть файл

@ -28,13 +28,15 @@ public:
// CreateContinuingFrame() does the default behavior of using the
// content delegate to create a new frame
virtual PRBool IsSplittable() const;
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
virtual nsIFrame* GetPrevInFlow() const;
virtual void SetPrevInFlow(nsIFrame*);
virtual nsIFrame* GetNextInFlow() const;
virtual void SetNextInFlow(nsIFrame*);
NS_IMETHOD IsSplittable(PRBool& aIsSplittable) const;
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
NS_IMETHOD GetPrevInFlow(nsIFrame*& aPrevInFlow) const;
NS_IMETHOD SetPrevInFlow(nsIFrame*);
NS_IMETHOD GetNextInFlow(nsIFrame*& aNextInFlow) const;
NS_IMETHOD SetNextInFlow(nsIFrame*);
/**
* Return the first frame in our current flow.
@ -46,11 +48,11 @@ public:
*/
nsIFrame* GetLastInFlow() const;
virtual void AppendToFlow(nsIFrame* aAfterFrame);
virtual void PrependToFlow(nsIFrame* aBeforeFrame);
virtual void RemoveFromFlow();
virtual void BreakFromPrevFlow();
virtual void BreakFromNextFlow();
NS_IMETHOD AppendToFlow(nsIFrame* aAfterFrame);
NS_IMETHOD PrependToFlow(nsIFrame* aAfterFrame);
NS_IMETHOD RemoveFromFlow();
NS_IMETHOD BreakFromPrevFlow();
NS_IMETHOD BreakFromNextFlow();
protected:
// Constructor. Takes as arguments the content object, the index in parent,

14
layout/base/src/nsStyleContext.cpp
Просмотреть файл

@ -526,7 +526,9 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
// It's text (!)
mMolecule.display = NS_STYLE_DISPLAY_INLINE;
mMolecule.cursor = NS_STYLE_CURSOR_IBEAM;
nsIContent* content = aParentFrame->GetContent();
nsIContent* content;
aParentFrame->GetContent(content);
nsIAtom* parentTag = content->GetTag();
parentTag->ToString(buf);
NS_RELEASE(content);
@ -539,9 +541,13 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
// mFont.mFont.decorations = NS_FONT_DECORATION_UNDERLINE;
// This simulates a <PRE><A>text inheritance rule
// Check the parent of the A
nsIFrame* parentParentFrame = aParentFrame->GetGeometricParent();
nsIFrame* parentParentFrame;
aParentFrame->GetGeometricParent(parentParentFrame);
if (nsnull != parentParentFrame) {
nsIContent* parentParentContent = parentParentFrame->GetContent();
nsIContent* parentParentContent;
parentParentFrame->GetContent(parentParentContent);
nsIAtom* parentParentTag = parentParentContent->GetTag();
parentParentTag->ToString(buf);
NS_RELEASE(parentParentTag);
@ -607,7 +613,7 @@ NS_NewStyleContext(nsIStyleContext** aInstancePtrResult,
nsIStyleContext* parent = nsnull;
if (nsnull != aParentFrame) {
parent = aParentFrame->GetStyleContext(aPresContext);
aParentFrame->GetStyleContext(aPresContext, parent);
NS_ASSERTION(nsnull != parent, "parent frame must have style context");
}

2
layout/base/src/nsStyleSet.cpp
Просмотреть файл

@ -454,7 +454,7 @@ nsIStyleContext* StyleSetImpl::ResolveStyleFor(nsIPresContext* aPresContext,
nsIStyleContext* parentContext = nsnull;
if (nsnull != aParentFrame) {
parentContext = aParentFrame->GetStyleContext(aPresContext);
aParentFrame->GetStyleContext(aPresContext, parentContext);
NS_ASSERTION(nsnull != parentContext, "parent must have style context");
}

32
layout/base/tests/TestContainerFrame.cpp
Просмотреть файл

@ -34,7 +34,7 @@ LengthOf(nsIFrame* aChildList)
PRInt32 result = 0;
while (nsnull != aChildList) {
aChildList = aChildList->GetNextSibling();
aChildList->GetNextSibling(aChildList);
result++;
}
@ -104,6 +104,8 @@ public:
// Allow public access to protected member functions
void PushChildren(nsIFrame* aFromChild, nsIFrame* aPrevSibling, PRBool aLastIsComplete);
PRBool DeleteChildsNextInFlow(nsIFrame* aChild);
PRInt32 ChildCount() {return mChildCount;}
};
SimpleContainer::SimpleContainer(nsIContent* aContent, PRInt32 aIndexInParent)
@ -190,42 +192,52 @@ TestChildEnumeration()
// Test indexing of child frames. nsnull should be returned for index
// values that are out of range
if (nsnull != f->ChildAt(-1)) {
nsIFrame* child;
f->ChildAt(-1, child);
if (nsnull != child) {
printf("ChildEnumeration: child index failed for index < 0\n");
return PR_FALSE;
}
if (c1 != f->ChildAt(0)) {
f->ChildAt(0, child);
if (c1 != child) {
printf("ChildEnumeration: wrong child at index: %d\n", 0);
return PR_FALSE;
}
if (c2 != f->ChildAt(1)) {
f->ChildAt(1, child);
if (c2 != child) {
printf("ChildEnumeration: wrong child at index: %d\n", 1);
return PR_FALSE;
}
if (c3 != f->ChildAt(2)) {
f->ChildAt(2, child);
if (c3 != child) {
printf("ChildEnumeration: wrong child at index: %d\n", 2);
return PR_FALSE;
}
if (nsnull != f->ChildAt(3)) {
f->ChildAt(3, child);
if (nsnull != child) {
printf("ChildEnumeration: child index failed for index >= child countn");
return PR_FALSE;
}
// Test first and last child member functions
if (f->FirstChild() != c1) {
f->FirstChild(child);
if (child != c1) {
printf("ChildEnumeration: wrong first child\n");
return PR_FALSE;
}
if (f->LastChild() != c3) {
f->LastChild(child);
if (child != c3) {
printf("ChildEnumeration: wrong last child\n");
return PR_FALSE;
}
#if 0
// Test IndexOf()
if ((f->IndexOf(c1) != 0) || (f->IndexOf(c2) != 1) || (f->IndexOf(c3) != 2)) {
printf("ChildEnumeration: index of failed\n");
return PR_FALSE;
}
#endif
return PR_TRUE;
}
@ -233,6 +245,7 @@ TestChildEnumeration()
///////////////////////////////////////////////////////////////////////////////
//
#if 0
// Test the push children method
//
// This tests the following:
@ -625,6 +638,7 @@ TestDeleteChildsNext()
return PR_TRUE;
}
#endif
///////////////////////////////////////////////////////////////////////////////
//
@ -646,6 +660,7 @@ int main(int argc, char** argv)
return -1;
}
#if 0
// Test the push children method
if (!TestPushChildren()) {
return -1;
@ -655,6 +670,7 @@ int main(int argc, char** argv)
if (!TestDeleteChildsNext()) {
return -1;
}
#endif
// Test being used as a pseudo frame
if (!TestAsPseudo()) {

292
layout/generic/nsBlockFrame.cpp
Просмотреть файл

@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
#endif
@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aY);
// Get the type of floater
nsIStyleContext* styleContext = floater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
floater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
// both the line and the floaters are pushed to the next-in-flow...
}
} else {
lineHeight = aState.lineStart->GetHeight();
nsSize size;
aState.lineStart->GetSize(size);
lineHeight = size.height;
}
// The first line always fits
@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
// Update maxElementSize
@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
{
nsIFrame* prevFrame = aState.prevLineLastFrame;
NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
"bad prev line");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevFrame->GetNextSibling(nextSibling);
NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
#endif
#ifdef NS_DEBUG
PRInt32 numKids = LengthOf(mFirstChild);
@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
PRInt32 kids = 0;
while (nsnull != kid) {
kids++;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
mChildCount = kids;
@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get kid and its style
// XXX How is this any different than what was passed in to us as aKidMol?
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
nsIContent* kid;
nsIStyleContext* kidSC;
kidFrame->GetContent(kid);
kidFrame->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
if (!AdvanceToNextLine(aCX, aState)) {
@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get the style for the last child, and see if it wanted to clear floaters.
// This handles the BR tag, which is the only inline element for which clear
// applies
nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
nsIStyleContext* lastChildSC;
lastFrame->GetStyleContext(aCX, lastChildSC);
nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID);
if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
ClearFloaters(aState, lastChildMol->clear);
@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
// Reflow splittable children
if (kidFrame->IsSplittable()) {
PRBool isSplittable;
kidFrame->IsSplittable(isSplittable);
if (isSplittable) {
// Update size info now that we are on the next line. Then
// reflow the child into the new available space.
GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
nsIFrame* prevKidFrame = nsnull;
for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
}
// Is the child complete?
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (frComplete == status) {
// Yes, the child is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
} else {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
mChildCount++;
@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
// Get the next child frame
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
push_done:;
// Update the child count member data
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
push_done:
#ifdef NS_DEBUG
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
PRInt32 len = LengthOf(mFirstChild);
NS_POSTCONDITION(len == mChildCount, "bad child count");
VerifyLastIsComplete();
@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
mFirstContentOffset = prev->NextChildOffset();
if (PR_FALSE == prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
// Place our children, one at a time until we are out of children
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
} else {
// Since kid has a prev-in-flow, use that to create the next
// frame.
kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
}
// Link child frame into the list of children. If the frame ends
// up not fitting and getting pushed, the PushKids code will fixup
// the child count for us.
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// We ran out of room.
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
NS_RELEASE(kid);
@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child didn't complete so create a continuing frame
kidPrevInFlow = kidFrame;
nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to the sibling list
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
kidFrame = continuingFrame;
mChildCount++;
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
}
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
#endif
} while (frNotComplete == status);
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// The child that we just reflowed is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
#endif
kidIndex++;
kidPrevInFlow = nsnull;
}
@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
// children OR we are a pseudo-frame and we ran into a block
// element. In either case our last content MUST be complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
push_done:
@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
PRBool result = PR_TRUE;
nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
while (nsnull != nextInFlow) {
// Get first available frame from the next-in-flow
nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
}
// Get style information for the pulled up kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// Push the kids that didn't fit back down to the next-in-flow
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
result = PR_FALSE;
@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child is not complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// Create a continuing frame for the incomplete child
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to our sibling list.
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
continuingFrame->SetNextSibling(nextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
kidFrame = continuingFrame;
@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
} else {
// The child has a next-in-flow, but it's not one of ours.
// It *must* be in one of our next-in-flows. Collect it
// then.
NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
"busted kid next-in-flow");
NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
break;
}
}
@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// in our next-in-flows (and reflowing any continunations they
// have). Therefore we KNOW that our last child is complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
}
#include "nsUnitConversion.h"/* XXX */
nsIFrame::ReflowStatus
nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
nsBlockReflowState state;
SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
return DoResizeReflow(aCX, state, aDesiredRect);
return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
}
nsIFrame::ReflowStatus
nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect)
nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// First reflow any existing frames
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete;
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aCX, aState);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// unmapped. We need to return the correct completion status,
// so see if there is more to reflow.
if (MoreToReflow(aCX)) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (MoreToReflow(aCX)) {
// Try and pull-up some children from a next-in-flow
if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
// If we still have unmapped children then create some new frames
if (MoreToReflow(aCX)) {
status = ReflowAppendedChildren(aCX, aState);
aStatus = ReflowAppendedChildren(aCX, aState);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
#endif
PushKids(aState);
status = frNotComplete;
aStatus = frNotComplete;
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there is room for it.
nscoord margin = aState.prevMaxPosBottomMargin -
@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
aDesiredRect.height = aState.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
#ifdef NOISY
ListTag(stdout);
@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
DumpFlow();
#endif
mCurrentState = nsnull;
return status;
return NS_OK;
}
void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
kid->JustifyReflow(aCX, availableSpace);
kid->SizeTo(r.width + availableSpace, r.height);
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
} else {
// XXX Get justification of multiple elements working
while (--lineLength >= 0) {
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
}
@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
}
}
nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent)
NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aCX, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsIFrame::ReflowStatus
nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete;
if (aReflowCommand.GetTarget() == this) {
// XXX for now, just do a complete reflow mapped (it'll kinda
@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else {
// XXX not yet implemented
@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
}
mCurrentState = nsnull;
return status;
return NS_OK;
}
PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
{
do {
nsIFrame* parent = aFrame->GetGeometricParent();
nsIFrame* parent;
aFrame->GetGeometricParent(parent);
// See if there are any non-zero sized child frames that precede aFrame
// in the child list
nsIFrame* child = parent->FirstChild();
nsIFrame* child;
parent->FirstChild(child);
while ((nsnull != child) && (aFrame != child)) {
nsSize size;
// Is the child zero-sized?
if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
child->GetSize(size);
if ((size.width > 0) || (size.height > 0)) {
// We found a non-zero sized child frame that precedes aFrame
return PR_FALSE;
}
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// aFrame is the left-most non-zero sized frame in its geometric parent.
@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
// todo list and we'll handle it when we flush out the line
if (IsLeftMostChild(aPlaceholder)) {
// Get the type of floater
nsIStyleContext* styleContext = aFloater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
aFloater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
}
}
void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsBlockFrame* flow = this;
for (;;) {
nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last-in-flow
nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
NS_RELEASE(kidSC);
NS_RELEASE(kid);
return;
return NS_OK;
}
// FALL THROUGH (and create frame)
@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
// Link child frame into the list of children
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}
PRIntn nsBlockFrame::GetSkipSides() const
@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
return eHTMLFrame_Block;
}
void nsBlockFrame::ListTag(FILE* out) const
NS_METHOD nsBlockFrame::ListTag(FILE* out) const
{
if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
fprintf(out, "*block(%d)@%p", mIndexInParent, this);
} else {
nsHTMLContainerFrame::ListTag(out);
}
return NS_OK;
}
#ifdef NS_DEBUG

42
layout/generic/nsBlockFrame.h
Просмотреть файл

@ -198,24 +198,27 @@ public:
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
virtual PRBool AddFloater(nsIPresContext* aCX,
nsIFrame* aFloater,
@ -224,7 +227,7 @@ public:
nsIFrame* aFloater,
PlaceholderFrame* aPlaceholder);
virtual void ListTag(FILE* out = stdout) const;
NS_IMETHOD ListTag(FILE* out = stdout) const;
virtual nsHTMLFrameType GetFrameType() const;
@ -277,9 +280,10 @@ protected:
const nsSize& aMaxSize, nsSize* aMaxElementSize,
nsISpaceManager* aSpaceManager);
ReflowStatus DoResizeReflow(nsIPresContext* aPresContext,
nsBlockReflowState& aState,
nsRect& aDesiredRect);
nsresult DoResizeReflow(nsIPresContext* aPresContext,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus);
PRBool ReflowMappedChildren(nsIPresContext* aPresContext,
nsBlockReflowState& aState);

292
layout/generic/nsBlockReflowState.cpp
Просмотреть файл

@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
#endif
@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aY);
// Get the type of floater
nsIStyleContext* styleContext = floater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
floater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
// both the line and the floaters are pushed to the next-in-flow...
}
} else {
lineHeight = aState.lineStart->GetHeight();
nsSize size;
aState.lineStart->GetSize(size);
lineHeight = size.height;
}
// The first line always fits
@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
// Update maxElementSize
@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
{
nsIFrame* prevFrame = aState.prevLineLastFrame;
NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
"bad prev line");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevFrame->GetNextSibling(nextSibling);
NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
#endif
#ifdef NS_DEBUG
PRInt32 numKids = LengthOf(mFirstChild);
@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
PRInt32 kids = 0;
while (nsnull != kid) {
kids++;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
mChildCount = kids;
@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get kid and its style
// XXX How is this any different than what was passed in to us as aKidMol?
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
nsIContent* kid;
nsIStyleContext* kidSC;
kidFrame->GetContent(kid);
kidFrame->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
if (!AdvanceToNextLine(aCX, aState)) {
@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get the style for the last child, and see if it wanted to clear floaters.
// This handles the BR tag, which is the only inline element for which clear
// applies
nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
nsIStyleContext* lastChildSC;
lastFrame->GetStyleContext(aCX, lastChildSC);
nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID);
if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
ClearFloaters(aState, lastChildMol->clear);
@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
// Reflow splittable children
if (kidFrame->IsSplittable()) {
PRBool isSplittable;
kidFrame->IsSplittable(isSplittable);
if (isSplittable) {
// Update size info now that we are on the next line. Then
// reflow the child into the new available space.
GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
nsIFrame* prevKidFrame = nsnull;
for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
}
// Is the child complete?
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (frComplete == status) {
// Yes, the child is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
} else {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
mChildCount++;
@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
// Get the next child frame
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
push_done:;
// Update the child count member data
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
push_done:
#ifdef NS_DEBUG
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
PRInt32 len = LengthOf(mFirstChild);
NS_POSTCONDITION(len == mChildCount, "bad child count");
VerifyLastIsComplete();
@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
mFirstContentOffset = prev->NextChildOffset();
if (PR_FALSE == prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
// Place our children, one at a time until we are out of children
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
} else {
// Since kid has a prev-in-flow, use that to create the next
// frame.
kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
}
// Link child frame into the list of children. If the frame ends
// up not fitting and getting pushed, the PushKids code will fixup
// the child count for us.
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// We ran out of room.
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
NS_RELEASE(kid);
@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child didn't complete so create a continuing frame
kidPrevInFlow = kidFrame;
nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to the sibling list
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
kidFrame = continuingFrame;
mChildCount++;
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
}
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
#endif
} while (frNotComplete == status);
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// The child that we just reflowed is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
#endif
kidIndex++;
kidPrevInFlow = nsnull;
}
@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
// children OR we are a pseudo-frame and we ran into a block
// element. In either case our last content MUST be complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
push_done:
@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
PRBool result = PR_TRUE;
nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
while (nsnull != nextInFlow) {
// Get first available frame from the next-in-flow
nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
}
// Get style information for the pulled up kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// Push the kids that didn't fit back down to the next-in-flow
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
result = PR_FALSE;
@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child is not complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// Create a continuing frame for the incomplete child
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to our sibling list.
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
continuingFrame->SetNextSibling(nextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
kidFrame = continuingFrame;
@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
} else {
// The child has a next-in-flow, but it's not one of ours.
// It *must* be in one of our next-in-flows. Collect it
// then.
NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
"busted kid next-in-flow");
NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
break;
}
}
@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// in our next-in-flows (and reflowing any continunations they
// have). Therefore we KNOW that our last child is complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
}
#include "nsUnitConversion.h"/* XXX */
nsIFrame::ReflowStatus
nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
nsBlockReflowState state;
SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
return DoResizeReflow(aCX, state, aDesiredRect);
return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
}
nsIFrame::ReflowStatus
nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect)
nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// First reflow any existing frames
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete;
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aCX, aState);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// unmapped. We need to return the correct completion status,
// so see if there is more to reflow.
if (MoreToReflow(aCX)) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (MoreToReflow(aCX)) {
// Try and pull-up some children from a next-in-flow
if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
// If we still have unmapped children then create some new frames
if (MoreToReflow(aCX)) {
status = ReflowAppendedChildren(aCX, aState);
aStatus = ReflowAppendedChildren(aCX, aState);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
#endif
PushKids(aState);
status = frNotComplete;
aStatus = frNotComplete;
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there is room for it.
nscoord margin = aState.prevMaxPosBottomMargin -
@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
aDesiredRect.height = aState.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
#ifdef NOISY
ListTag(stdout);
@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
DumpFlow();
#endif
mCurrentState = nsnull;
return status;
return NS_OK;
}
void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
kid->JustifyReflow(aCX, availableSpace);
kid->SizeTo(r.width + availableSpace, r.height);
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
} else {
// XXX Get justification of multiple elements working
while (--lineLength >= 0) {
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
}
@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
}
}
nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent)
NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aCX, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsIFrame::ReflowStatus
nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete;
if (aReflowCommand.GetTarget() == this) {
// XXX for now, just do a complete reflow mapped (it'll kinda
@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else {
// XXX not yet implemented
@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
}
mCurrentState = nsnull;
return status;
return NS_OK;
}
PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
{
do {
nsIFrame* parent = aFrame->GetGeometricParent();
nsIFrame* parent;
aFrame->GetGeometricParent(parent);
// See if there are any non-zero sized child frames that precede aFrame
// in the child list
nsIFrame* child = parent->FirstChild();
nsIFrame* child;
parent->FirstChild(child);
while ((nsnull != child) && (aFrame != child)) {
nsSize size;
// Is the child zero-sized?
if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
child->GetSize(size);
if ((size.width > 0) || (size.height > 0)) {
// We found a non-zero sized child frame that precedes aFrame
return PR_FALSE;
}
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// aFrame is the left-most non-zero sized frame in its geometric parent.
@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
// todo list and we'll handle it when we flush out the line
if (IsLeftMostChild(aPlaceholder)) {
// Get the type of floater
nsIStyleContext* styleContext = aFloater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
aFloater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
}
}
void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsBlockFrame* flow = this;
for (;;) {
nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last-in-flow
nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
NS_RELEASE(kidSC);
NS_RELEASE(kid);
return;
return NS_OK;
}
// FALL THROUGH (and create frame)
@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
// Link child frame into the list of children
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}
PRIntn nsBlockFrame::GetSkipSides() const
@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
return eHTMLFrame_Block;
}
void nsBlockFrame::ListTag(FILE* out) const
NS_METHOD nsBlockFrame::ListTag(FILE* out) const
{
if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
fprintf(out, "*block(%d)@%p", mIndexInParent, this);
} else {
nsHTMLContainerFrame::ListTag(out);
}
return NS_OK;
}
#ifdef NS_DEBUG

292
layout/generic/nsBlockReflowState.h
Просмотреть файл

@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
#endif
@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aY);
// Get the type of floater
nsIStyleContext* styleContext = floater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
floater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
// both the line and the floaters are pushed to the next-in-flow...
}
} else {
lineHeight = aState.lineStart->GetHeight();
nsSize size;
aState.lineStart->GetSize(size);
lineHeight = size.height;
}
// The first line always fits
@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
// Update maxElementSize
@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
{
nsIFrame* prevFrame = aState.prevLineLastFrame;
NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
"bad prev line");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevFrame->GetNextSibling(nextSibling);
NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
#endif
#ifdef NS_DEBUG
PRInt32 numKids = LengthOf(mFirstChild);
@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
PRInt32 kids = 0;
while (nsnull != kid) {
kids++;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
mChildCount = kids;
@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get kid and its style
// XXX How is this any different than what was passed in to us as aKidMol?
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
nsIContent* kid;
nsIStyleContext* kidSC;
kidFrame->GetContent(kid);
kidFrame->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
if (!AdvanceToNextLine(aCX, aState)) {
@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get the style for the last child, and see if it wanted to clear floaters.
// This handles the BR tag, which is the only inline element for which clear
// applies
nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
nsIStyleContext* lastChildSC;
lastFrame->GetStyleContext(aCX, lastChildSC);
nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID);
if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
ClearFloaters(aState, lastChildMol->clear);
@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
// Reflow splittable children
if (kidFrame->IsSplittable()) {
PRBool isSplittable;
kidFrame->IsSplittable(isSplittable);
if (isSplittable) {
// Update size info now that we are on the next line. Then
// reflow the child into the new available space.
GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
nsIFrame* prevKidFrame = nsnull;
for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
}
// Is the child complete?
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (frComplete == status) {
// Yes, the child is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
} else {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
mChildCount++;
@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
// Get the next child frame
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
push_done:;
// Update the child count member data
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
push_done:
#ifdef NS_DEBUG
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
PRInt32 len = LengthOf(mFirstChild);
NS_POSTCONDITION(len == mChildCount, "bad child count");
VerifyLastIsComplete();
@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
mFirstContentOffset = prev->NextChildOffset();
if (PR_FALSE == prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
// Place our children, one at a time until we are out of children
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
} else {
// Since kid has a prev-in-flow, use that to create the next
// frame.
kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
}
// Link child frame into the list of children. If the frame ends
// up not fitting and getting pushed, the PushKids code will fixup
// the child count for us.
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// We ran out of room.
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
NS_RELEASE(kid);
@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child didn't complete so create a continuing frame
kidPrevInFlow = kidFrame;
nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to the sibling list
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
kidFrame = continuingFrame;
mChildCount++;
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
}
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
#endif
} while (frNotComplete == status);
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// The child that we just reflowed is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
#endif
kidIndex++;
kidPrevInFlow = nsnull;
}
@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
// children OR we are a pseudo-frame and we ran into a block
// element. In either case our last content MUST be complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
push_done:
@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
PRBool result = PR_TRUE;
nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
while (nsnull != nextInFlow) {
// Get first available frame from the next-in-flow
nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
}
// Get style information for the pulled up kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// Push the kids that didn't fit back down to the next-in-flow
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
result = PR_FALSE;
@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child is not complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// Create a continuing frame for the incomplete child
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to our sibling list.
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
continuingFrame->SetNextSibling(nextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
kidFrame = continuingFrame;
@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
} else {
// The child has a next-in-flow, but it's not one of ours.
// It *must* be in one of our next-in-flows. Collect it
// then.
NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
"busted kid next-in-flow");
NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
break;
}
}
@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// in our next-in-flows (and reflowing any continunations they
// have). Therefore we KNOW that our last child is complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
}
#include "nsUnitConversion.h"/* XXX */
nsIFrame::ReflowStatus
nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
nsBlockReflowState state;
SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
return DoResizeReflow(aCX, state, aDesiredRect);
return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
}
nsIFrame::ReflowStatus
nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect)
nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// First reflow any existing frames
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete;
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aCX, aState);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// unmapped. We need to return the correct completion status,
// so see if there is more to reflow.
if (MoreToReflow(aCX)) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (MoreToReflow(aCX)) {
// Try and pull-up some children from a next-in-flow
if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
// If we still have unmapped children then create some new frames
if (MoreToReflow(aCX)) {
status = ReflowAppendedChildren(aCX, aState);
aStatus = ReflowAppendedChildren(aCX, aState);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
#endif
PushKids(aState);
status = frNotComplete;
aStatus = frNotComplete;
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there is room for it.
nscoord margin = aState.prevMaxPosBottomMargin -
@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
aDesiredRect.height = aState.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
#ifdef NOISY
ListTag(stdout);
@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
DumpFlow();
#endif
mCurrentState = nsnull;
return status;
return NS_OK;
}
void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
kid->JustifyReflow(aCX, availableSpace);
kid->SizeTo(r.width + availableSpace, r.height);
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
} else {
// XXX Get justification of multiple elements working
while (--lineLength >= 0) {
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
}
@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
}
}
nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent)
NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aCX, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsIFrame::ReflowStatus
nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete;
if (aReflowCommand.GetTarget() == this) {
// XXX for now, just do a complete reflow mapped (it'll kinda
@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else {
// XXX not yet implemented
@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
}
mCurrentState = nsnull;
return status;
return NS_OK;
}
PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
{
do {
nsIFrame* parent = aFrame->GetGeometricParent();
nsIFrame* parent;
aFrame->GetGeometricParent(parent);
// See if there are any non-zero sized child frames that precede aFrame
// in the child list
nsIFrame* child = parent->FirstChild();
nsIFrame* child;
parent->FirstChild(child);
while ((nsnull != child) && (aFrame != child)) {
nsSize size;
// Is the child zero-sized?
if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
child->GetSize(size);
if ((size.width > 0) || (size.height > 0)) {
// We found a non-zero sized child frame that precedes aFrame
return PR_FALSE;
}
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// aFrame is the left-most non-zero sized frame in its geometric parent.
@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
// todo list and we'll handle it when we flush out the line
if (IsLeftMostChild(aPlaceholder)) {
// Get the type of floater
nsIStyleContext* styleContext = aFloater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
aFloater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
}
}
void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsBlockFrame* flow = this;
for (;;) {
nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last-in-flow
nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
NS_RELEASE(kidSC);
NS_RELEASE(kid);
return;
return NS_OK;
}
// FALL THROUGH (and create frame)
@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
// Link child frame into the list of children
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}
PRIntn nsBlockFrame::GetSkipSides() const
@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
return eHTMLFrame_Block;
}
void nsBlockFrame::ListTag(FILE* out) const
NS_METHOD nsBlockFrame::ListTag(FILE* out) const
{
if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
fprintf(out, "*block(%d)@%p", mIndexInParent, this);
} else {
nsHTMLContainerFrame::ListTag(out);
}
return NS_OK;
}
#ifdef NS_DEBUG

35
layout/generic/nsHTMLContainerFrame.cpp
Просмотреть файл

@ -44,10 +44,9 @@ nsHTMLContainerFrame::~nsHTMLContainerFrame()
{
}
void
nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// Do not paint ourselves if we are a pseudo-frame
if (PR_FALSE == IsPseudoFrame()) {
@ -68,6 +67,7 @@ nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
aRenderingContext.SetColor(NS_RGB(255,0,0));
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
}
return NS_OK;
}
void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
@ -96,14 +96,15 @@ void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
}
}
nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent)
NS_METHOD nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
nsEventStatus rv = nsEventStatus_eIgnore;
aEventStatus = nsEventStatus_eIgnore;
switch (aEvent->message) {
case NS_MOUSE_LEFT_BUTTON_UP:
if (nsEventStatus_eIgnore ==
nsContainerFrame::HandleEvent(aPresContext, aEvent)) {
nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus)) {
// If our child didn't take the click then since we are an
// anchor, we take the click.
nsIAtom* tag = mContent->GetTag();
@ -112,7 +113,7 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
mContent->GetAttribute("href", href);
mContent->GetAttribute("target", target);
TriggerLink(aPresContext, base, href, target);
rv = nsEventStatus_eConsumeNoDefault;
aEventStatus = nsEventStatus_eConsumeNoDefault;
}
NS_IF_RELEASE(tag);
}
@ -123,15 +124,16 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
break;
default:
rv = nsContainerFrame::HandleEvent(aPresContext, aEvent);
nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
break;
}
return rv;
return NS_OK;
}
PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame)
NS_METHOD nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor)
{
nsStyleMolecule* mol = (nsStyleMolecule*)
mStyleContext->GetData(kStyleMoleculeSID);
@ -139,9 +141,10 @@ PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
// If this container has a particular cursor, use it, otherwise
// let the child decide.
*aFrame = this;
return (PRInt32) mol->cursor;
aCursor = (PRInt32)mol->cursor;
return NS_OK;
}
return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame);
return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame, aCursor);
}
#if 0

18
layout/generic/nsHTMLContainerFrame.h
Просмотреть файл

@ -30,16 +30,18 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent);
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame);
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor);
#if 0
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,

199
layout/generic/nsIFrame.h
Просмотреть файл

@ -34,12 +34,10 @@ class nsIView;
class nsIWidget;
class nsReflowCommand;
struct nsStyleStruct;
struct nsGUIEvent;
struct nsPoint;
struct nsRect;
struct nsReflowMetrics;
struct nsStyleStruct;
// IID for the nsIFrame interface {12B193D0-9F70-11d1-8500-00A02468FAB6}
#define NS_IFRAME_IID \
@ -81,13 +79,13 @@ public:
* QueryInterface() defined in nsISupports. This is the only member
* function of nsISupports that is public.
*/
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0;
/**
* Deletes this frame and each of its child frames (recursively calls
* DeleteFrame() for each child)
*/
virtual void DeleteFrame() = 0;
NS_IMETHOD DeleteFrame() = 0;
/**
* Get the content object associated with this frame. Adds a reference to
@ -95,66 +93,73 @@ public:
*
* @see nsISupports#Release()
*/
virtual nsIContent* GetContent() const = 0;
NS_IMETHOD GetContent(nsIContent*& aContent) const = 0;
/**
* Get/Set the frame's index in parent.
*/
virtual PRInt32 GetIndexInParent() const = 0;
virtual void SetIndexInParent(PRInt32 aIndexInParent) = 0;
NS_IMETHOD GetIndexInParent(PRInt32& aIndexInParent) const = 0;
NS_IMETHOD SetIndexInParent(PRInt32 aIndexInParent) = 0;
/**
* Get the style context associated with this frame. Note that GetStyleContext()
* adds a reference to the style context so the caller must do a release.
*
* @see #nsISupports#Release()
* @see nsISupports#Release()
*/
virtual nsIStyleContext* GetStyleContext(nsIPresContext* aContext) = 0;
virtual void SetStyleContext(nsIStyleContext* aContext) = 0;
NS_IMETHOD GetStyleContext(nsIPresContext* aContext,
nsIStyleContext*& aStyleContext) = 0;
NS_IMETHOD SetStyleContext(nsIStyleContext* aContext) = 0;
/**
*
* Get the style data associated with this frame
*
*
*/
virtual nsStyleStruct* GetStyleData(const nsIID& aSID) = 0;
NS_IMETHOD GetStyleData(const nsIID& aSID, nsStyleStruct*& aStyleStruct) = 0;
/**
* Accessor functions for geometric and content parent.
*/
virtual nsIFrame* GetContentParent() const = 0;
virtual void SetContentParent(const nsIFrame* aParent) = 0;
virtual nsIFrame* GetGeometricParent() const = 0;
virtual void SetGeometricParent(const nsIFrame* aParent) = 0;
NS_IMETHOD GetContentParent(nsIFrame*& aParent) const = 0;
NS_IMETHOD SetContentParent(const nsIFrame* aParent) = 0;
NS_IMETHOD GetGeometricParent(nsIFrame*& aParent) const = 0;
NS_IMETHOD SetGeometricParent(const nsIFrame* aParent) = 0;
/**
* Bounding rect of the frame. The values are in twips, and the origin is
* relative to the upper-left of the geometric parent. The size includes the
* content area, borders, and padding.
*/
virtual nsRect GetRect() const = 0;
virtual void GetRect(nsRect& aRect) const = 0;
virtual void GetOrigin(nsPoint& aPoint) const = 0;
virtual nscoord GetWidth() const = 0;
virtual nscoord GetHeight() const = 0;
virtual void SetRect(const nsRect& aRect) = 0;
virtual void MoveTo(nscoord aX, nscoord aY) = 0;
virtual void SizeTo(nscoord aWidth, nscoord aHeight) = 0;
NS_IMETHOD GetRect(nsRect& aRect) const = 0;
NS_IMETHOD GetOrigin(nsPoint& aPoint) const = 0;
NS_IMETHOD GetSize(nsSize& aSize) const = 0;
NS_IMETHOD SetRect(const nsRect& aRect) = 0;
NS_IMETHOD MoveTo(nscoord aX, nscoord aY) = 0;
NS_IMETHOD SizeTo(nscoord aWidth, nscoord aHeight) = 0;
/**
* Child frame enumeration
*/
NS_IMETHOD ChildCount(PRInt32& aChildCount) const = 0;
NS_IMETHOD ChildAt(PRInt32 aIndex, nsIFrame*& aFrame) const = 0;
NS_IMETHOD IndexOf(const nsIFrame* aChild, PRInt32& aIndex) const = 0;
NS_IMETHOD FirstChild(nsIFrame*& aFirstChild) const = 0;
NS_IMETHOD NextChild(const nsIFrame* aChild, nsIFrame*& aNextChild) const = 0;
NS_IMETHOD PrevChild(const nsIFrame* aChild, nsIFrame*& aPrevChild) const = 0;
NS_IMETHOD LastChild(nsIFrame*& aLastChild) const = 0;
/**
* Painting
*/
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect) = 0;
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect) = 0;
/**
* Handle an event.
*/
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent) = 0;
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus) = 0;
/**
* Get the cursor for a given point in the frame tree. The
@ -162,20 +167,10 @@ public:
* no cursor is wanted). In addition, if a cursor is desired
* then *aFrame is set to the frame that wants the cursor.
*/
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame) = 0;
/**
* Child frame enumeration
*/
virtual PRInt32 ChildCount() const = 0;
virtual nsIFrame* ChildAt(PRInt32 aIndex) const = 0;
virtual PRInt32 IndexOf(const nsIFrame* aChild) const = 0;
virtual nsIFrame* FirstChild() const = 0;
virtual nsIFrame* NextChild(const nsIFrame* aChild) const = 0;
virtual nsIFrame* PrevChild(const nsIFrame* aChild) const = 0;
virtual nsIFrame* LastChild() const = 0;
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor) = 0;
/**
* Reflow status returned by the reflow methods
@ -206,10 +201,11 @@ public:
* a maximum element size. The maximum element size must be less than or
* equal to your desired size.
*/
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize) = 0;
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus) = 0;
/**
* Post-processing reflow method invoked when justification is enabled.
@ -218,8 +214,8 @@ public:
* @param aAvailableSpace The amount of available space that the frame
* should distribute internally.
*/
virtual void JustifyReflow(nsIPresContext* aPresContext,
nscoord aAvailableSpace) = 0;
NS_IMETHOD JustifyReflow(nsIPresContext* aPresContext,
nscoord aAvailableSpace) = 0;
/**
* Incremental reflow. The reflow command contains information about the
@ -243,10 +239,11 @@ public:
* @see nsReflowCommand#GetTarget()
* @see nsReflowCommand#GetType()
*/
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand) = 0;
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus) = 0;
/**
* This call is invoked when content is appended to the content
@ -256,9 +253,9 @@ public:
* the call must generate reflow commands that will incrementally
* reflow and repair the damaged portion of the frame tree.
*/
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer) = 0;
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer) = 0;
/**
* This call is invoked when content is inserted in the content
@ -271,11 +268,11 @@ public:
* @param aIndexInParent the index in the content container where
* the new content was inserted.
*/
virtual void ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
NS_IMETHOD ContentInserted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
/**
* This call is invoked when content is replaced in the content
@ -288,12 +285,12 @@ public:
*
* @param aIndexInParent the index in the content container where
* the new content was inserted. */
virtual void ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent) = 0;
NS_IMETHOD ContentReplaced(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aOldChild,
nsIContent* aNewChild,
PRInt32 aIndexInParent) = 0;
/**
* This call is invoked when content is deleted from the content
@ -306,11 +303,11 @@ public:
* @param aIndexInParent the index in the content container where
* the new content was deleted.
*/
virtual void ContentDeleted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
NS_IMETHOD ContentDeleted(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer,
nsIContent* aChild,
PRInt32 aIndexInParent) = 0;
/**
* Return the reflow metrics for this frame. If the frame is a
@ -320,43 +317,45 @@ public:
* ascent of the line's children). Note that the metrics returned
* apply to the frame as it exists at the time of the call.
*/
virtual void GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics) = 0;
NS_IMETHOD GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics) = 0;
/**
* Flow member functions. CreateContinuingFrame() is responsible for appending
* the continuing frame to the flow.
*/
virtual PRBool IsSplittable() const = 0;
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent) = 0;
virtual nsIFrame* GetPrevInFlow() const = 0;
virtual void SetPrevInFlow(nsIFrame*) = 0;
virtual nsIFrame* GetNextInFlow() const = 0;
virtual void SetNextInFlow(nsIFrame*) = 0;
NS_IMETHOD IsSplittable(PRBool& aIsSplittable) const = 0;
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame) = 0;
virtual void AppendToFlow(nsIFrame* aAfterFrame) = 0;
virtual void PrependToFlow(nsIFrame* aBeforeFrame) = 0;
virtual void RemoveFromFlow() = 0;
virtual void BreakFromPrevFlow() = 0;
virtual void BreakFromNextFlow() = 0;
NS_IMETHOD GetPrevInFlow(nsIFrame*& aPrevInFlow) const = 0;
NS_IMETHOD SetPrevInFlow(nsIFrame*) = 0;
NS_IMETHOD GetNextInFlow(nsIFrame*& aNextInFlow) const = 0;
NS_IMETHOD SetNextInFlow(nsIFrame*) = 0;
NS_IMETHOD AppendToFlow(nsIFrame* aAfterFrame) = 0;
NS_IMETHOD PrependToFlow(nsIFrame* aBeforeFrame) = 0;
NS_IMETHOD RemoveFromFlow() = 0;
NS_IMETHOD BreakFromPrevFlow() = 0;
NS_IMETHOD BreakFromNextFlow() = 0;
/**
* Accessor functions to get/set the associated view object
*/
virtual nsIView* GetView() const = 0; // may be null
virtual void SetView(nsIView* aView) = 0;
NS_IMETHOD GetView(nsIView*& aView) const = 0; // may be null
NS_IMETHOD SetView(nsIView* aView) = 0;
/**
* Find the first geometric parent that has a view
*/
virtual nsIFrame* GetParentWithView() const = 0;
NS_IMETHOD GetParentWithView(nsIFrame*& aParent) const = 0;
/**
* Returns the offset from this frame to the closest geometric parent that
* has a view. Also returns the containing view or null in case of error
*/
virtual nsIView* GetOffsetFromView(nsPoint& aOffset) const = 0;
NS_IMETHOD GetOffsetFromView(nsPoint& aOffset, nsIView*& aView) const = 0;
/**
* Returns the window that contains this frame. If this frame has a
@ -364,18 +363,18 @@ public:
* returned, otherwise this frame's geometric parent is checked
* recursively upwards.
*/
virtual nsIWidget* GetWindow() const = 0;
NS_IMETHOD GetWindow(nsIWidget*&) const = 0;
/**
* Sibling pointer used to link together frames
*/
virtual nsIFrame* GetNextSibling() const = 0;
virtual void SetNextSibling(nsIFrame* aNextSibling) = 0;
NS_IMETHOD GetNextSibling(nsIFrame*& aNextSibling) const = 0;
NS_IMETHOD SetNextSibling(nsIFrame* aNextSibling) = 0;
// Debugging
virtual void List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
virtual void ListTag(FILE* out = stdout) const = 0;
virtual void VerifyTree() const = 0;
NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const= 0;
NS_IMETHOD ListTag(FILE* out = stdout) const = 0;
NS_IMETHOD VerifyTree() const = 0;
// Show frame borders when rendering
static NS_LAYOUT void ShowFrameBorders(PRBool aEnable);

158
layout/generic/nsInlineFrame.cpp
Просмотреть файл

@ -241,17 +241,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No, the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -264,7 +269,9 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -274,16 +281,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
}
// Get the next child frame
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
// XXX talk with troy about checking for available space here
}
// Update the child count member data
mChildCount = childCount;
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
#ifdef NS_DEBUG
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
VerifyLastIsComplete();
#endif
return result;
@ -309,7 +322,9 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -338,7 +353,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
nsIFrame* next;
nextInFlow->GetNextInFlow(next);
nextInFlow = (nsInlineFrame*)next;
continue;
}
}
@ -346,8 +364,12 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetWidth() > aState.availSize.width) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.width > aState.availSize.width) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -369,7 +391,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
PlaceChild(kidFrame, mChildCount, aState, kidSize, pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -378,7 +400,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* kidContentParent;
kidFrame->GetContentParent(kidContentParent);
if (nextInFlow == kidContentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -398,13 +423,16 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -432,7 +460,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -452,7 +480,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
nsIFrame* next;
nextInFlow->GetNextInFlow(next);
nextInFlow = (nsInlineFrame*)next;
}
#endif
}
@ -492,7 +523,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
mFirstContentOffset = prev->NextChildOffset();
if (!prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
mLastContentIsComplete = PR_TRUE;
@ -501,8 +532,9 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsSize kidMaxElementSize;
nsSize* pKidMaxElementSize = (nsnull != aState.maxElementSize) ? &kidMaxElementSize : nsnull;
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -558,7 +590,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
}
kidFrame->SetStyleContext(kidStyleContext);
} else {
kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
}
NS_RELEASE(kid);
NS_RELEASE(kidStyleContext);
@ -606,7 +638,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
done:;
// Update the content mapping
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
PRInt32 len = LengthOf(mFirstChild);
@ -618,11 +650,11 @@ done:;
return result;
}
nsIFrame::ReflowStatus
nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -630,7 +662,8 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
//XXX not now NS_PRECONDITION((aMaxSize.width > 0) && (aMaxSize.height > 0), "unexpected max size");
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete; // initialize out parameter
// Get the style molecule
nsStyleFont* styleFont =
@ -651,7 +684,7 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
reflowMappedOK = ReflowMappedChildren(aPresContext, state);
if (PR_FALSE == reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -661,18 +694,18 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
if (state.availSize.width <= 0) {
// No space left. Don't try to pull-up children or reflow unmapped
if (NextChildOffset() < mContent->ChildCount()) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (NextChildOffset() < mContent->ChildCount()) {
// Try and pull-up some children from a next-in-flow
if (PullUpChildren(aPresContext, state)) {
// If we still have unmapped children then create some new frames
if (NextChildOffset() < mContent->ChildCount()) {
status = ReflowUnmappedChildren(aPresContext, state);
aStatus = ReflowUnmappedChildren(aPresContext, state);
}
} else {
// We were unable to pull-up all the existing frames from the next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -694,9 +727,9 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
aDesiredSize.height = aDesiredSize.ascent + aDesiredSize.descent;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
return status;
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////////
@ -717,8 +750,8 @@ PRIntn nsInlineFrame::GetSkipSides() const
// Incremental reflow support
void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics)
NS_METHOD nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics)
{
nscoord maxAscent = 0;
nscoord maxDescent = 0;
@ -728,7 +761,7 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
kid->GetReflowMetrics(aPresContext, kidMetrics);
if (kidMetrics.ascent > maxAscent) maxAscent = kidMetrics.ascent;
if (kidMetrics.descent > maxDescent) maxDescent = kidMetrics.descent;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
// XXX what about border & padding
@ -736,6 +769,8 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
aMetrics.height = mRect.height;
aMetrics.ascent = maxAscent;
aMetrics.descent = maxDescent;
return NS_OK;
}
/**
@ -765,7 +800,7 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
// XXX Factor in left and right margins
x += kidMetrics.width;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
i++;
}
aState.maxAscent = maxAscent;
@ -774,13 +809,13 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
return (nsnull == aSkipChild) ? 0 : i;
}
nsIFrame::ReflowStatus
nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete; // initialize out parameter
#if 0
if (aReflowCommand.GetTarget() == this) {
@ -794,7 +829,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
while (nsnull != flow->mNextInFlow) {
flow = flow->mNextInFlow;
}
status = flow->ReflowUnmappedChildren(...);
aStatus = flow->ReflowUnmappedChildren(...);
break;
case nsReflowCommand::rcContentInserted:
@ -875,7 +910,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
// Now pass reflow command down to our child to handle
nsReflowMetrics kidMetrics;
status = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
aStatus = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
// XXX what do we do when the nextInChain's completion status changes?
// XXX if kid == LastChild() then mLastContentIsComplete needs updating
@ -909,13 +944,13 @@ nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
// Update other children that are impacted by the change in
// nextInChain. In addition, re-apply vertical alignment and
// relative positioning to the children on the line.
status = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
kidMetrics, status);
aStatus = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
kidMetrics, aStatus);
}
}
#endif
return status;
return NS_OK;
}
@ -961,7 +996,7 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
}
x += r.width;
// XXX factor in left and right margins
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
// Vertically align the children
@ -981,25 +1016,19 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
// My container has new content at the end of it. Create frames for
// the appended content and then generate an incremental reflow
// command for ourselves.
void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsInlineFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsInlineFrame* flow = this;
for (;;) {
nsInlineFrame* next = (nsInlineFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last in flow
nsInlineFrame* flow = (nsInlineFrame*)GetLastInFlow();
// Get index of where the content has been appended
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
// Create frames for each new child
for (;;) {
// Get the next content object
@ -1027,4 +1056,5 @@ void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}

41
layout/generic/nsLeafFrame.cpp
Просмотреть файл

@ -33,9 +33,9 @@ nsLeafFrame::~nsLeafFrame()
{
}
void nsLeafFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsLeafFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsStyleColor* myColor =
(nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@ -45,13 +45,14 @@ void nsLeafFrame::Paint(nsIPresContext& aPresContext,
aDirtyRect, mRect, *myColor);
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
aDirtyRect, mRect, *myMol, 0);
return NS_OK;
}
nsIFrame::ReflowStatus
nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
// XXX add in code to check for width/height being set via css
// and if set use them instead of calling GetDesiredSize.
@ -62,14 +63,15 @@ nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
aMaxElementSize->width = aDesiredSize.width;
aMaxElementSize->height = aDesiredSize.height;
}
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
// XXX Unless the reflow command is a style change, we should
// just return the current size, otherwise we should invoke
@ -80,7 +82,8 @@ nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
GetDesiredSize(aPresContext, aDesiredSize, aMaxSize);
AddBordersAndPadding(aPresContext, aDesiredSize);
return frComplete;
aStatus = frComplete;
return NS_OK;
}
// XXX how should border&padding effect baseline alignment?
@ -109,9 +112,11 @@ void nsLeafFrame::GetInnerArea(nsIPresContext* aPresContext,
(mol->borderPadding.top + mol->borderPadding.bottom);
}
nsIFrame* nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
NS_NOTREACHED("Attempt to split the unsplittable");
return nsnull;
aContinuingFrame = nsnull;
return NS_OK;
}

29
layout/generic/nsLeafFrame.h
Просмотреть файл

@ -28,22 +28,25 @@
*/
class nsLeafFrame : public nsFrame {
public:
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
protected:
nsLeafFrame(nsIContent* aContent,

73
layout/generic/nsPageFrame.cpp
Просмотреть файл

@ -23,8 +23,8 @@
#include "nsReflowCommand.h"
#include "nsIRenderingContext.h"
PageFrame::PageFrame(nsIContent* aContent, nsIFrame* aParent)
: nsContainerFrame(aContent, aParent->GetIndexInParent(), aParent)
PageFrame::PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent)
: nsContainerFrame(aContent, aIndexInParent, aParent)
{
}
@ -56,16 +56,16 @@ void PageFrame::CreateFirstChild(nsIPresContext* aPresContext)
}
}
nsIFrame::ReflowStatus
PageFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD PageFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
#endif
ReflowStatus result = frComplete;
aStatus = frComplete; // initialize out parameter
// Do we have any children?
if (nsnull == mFirstChild) {
@ -76,10 +76,11 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
PageFrame* prevPage = (PageFrame*)mPrevInFlow;
NS_ASSERTION(!prevPage->mLastContentIsComplete, "bad continuing page");
nsIFrame* prevLastChild = prevPage->LastChild();
nsIFrame* prevLastChild;
prevPage->LastChild(prevLastChild);
// Create a continuing child of the previous page's last child
mFirstChild = prevLastChild->CreateContinuingFrame(aPresContext, this);
prevLastChild->CreateContinuingFrame(aPresContext, this, mFirstChild);
mChildCount = 1;
mLastContentOffset = mFirstContentOffset;
}
@ -89,9 +90,9 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
// XXX Pay attention to the page's border and padding...
if (nsnull != mFirstChild) {
// Get the child's desired size
result = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
aMaxElementSize);
mLastContentIsComplete = PRBool(result == frComplete);
aStatus = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
aMaxElementSize);
mLastContentIsComplete = PRBool(aStatus == frComplete);
// Make sure the child is at least as tall as our max size (the containing window)
if (aDesiredSize.height < aMaxSize.height) {
@ -103,8 +104,11 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
mFirstChild->SetRect(rect);
// Is the frame complete?
if (frComplete == result) {
NS_ASSERTION(nsnull == mFirstChild->GetNextInFlow(), "bad child flow list");
if (frComplete == aStatus) {
nsIFrame* childNextInFlow;
mFirstChild->GetNextInFlow(childNextInFlow);
NS_ASSERTION(nsnull == childNextInFlow, "bad child flow list");
}
}
@ -113,28 +117,27 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
aDesiredSize.height = aMaxSize.height;
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
return result;
return NS_OK;
}
// XXX Do something sensible in page mode...
nsIFrame::ReflowStatus
PageFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD PageFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
// We don't expect the target of the reflow command to be page frame
NS_ASSERTION(aReflowCommand.GetTarget() != this, "page frame is reflow command target");
nsSize maxSize(aMaxSize.width, NS_UNCONSTRAINEDSIZE);
ReflowStatus status;
nsIFrame* child;
// Dispatch the reflow command to our pseudo frame. Allow it to be as high
// as it wants
status = aReflowCommand.Next(aDesiredSize, maxSize, child);
aStatus = aReflowCommand.Next(aDesiredSize, maxSize, child);
// Place and size the child. Make sure the child is at least as
// tall as our max size (the containing window)
@ -148,20 +151,22 @@ PageFrame::IncrementalReflow(nsIPresContext* aPresContext,
child->SetRect(rect);
}
return status;
return NS_OK;
}
nsIFrame* PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
PageFrame* cf = new PageFrame(mContent, aParent);
PageFrame* cf = new PageFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
void PageFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD PageFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect);
@ -169,10 +174,12 @@ void PageFrame::Paint(nsIPresContext& aPresContext,
// where each page begins and ends
aRenderingContext.SetColor(NS_RGB(0, 0, 0));
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
return NS_OK;
}
void PageFrame::ListTag(FILE* out) const
NS_METHOD PageFrame::ListTag(FILE* out) const
{
fprintf(out, "*PAGE@%p", this);
return NS_OK;
}

33
layout/generic/nsPageFrame.h
Просмотреть файл

@ -23,27 +23,30 @@
// Pseudo frame created by the root content frame
class PageFrame : public nsContainerFrame {
public:
PageFrame(nsIContent* aContent, nsIFrame* aParent);
PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
// Debugging
virtual void ListTag(FILE* out = stdout) const;
NS_IMETHOD ListTag(FILE* out = stdout) const;
protected:
void CreateFirstChild(nsIPresContext* aPresContext);

19
layout/generic/nsPlaceholderFrame.cpp
Просмотреть файл

@ -52,16 +52,16 @@ PlaceholderFrame::~PlaceholderFrame()
{
}
nsIFrame::ReflowStatus
PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
// Get the floater container in which we're inserted
nsIFloaterContainer* container = nsnull;
for (nsIFrame* parent = mGeometricParent; parent; parent = parent->GetGeometricParent()) {
for (nsIFrame* parent = mGeometricParent; parent; parent->GetGeometricParent(parent)) {
if (NS_OK == parent->QueryInterface(kIFloaterContainerIID, (void**)&container)) {
break;
}
@ -82,7 +82,7 @@ PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
// Resize reflow the anchored item into the available space
// XXX Check for complete?
mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
mAnchoredItem->SizeTo(aDesiredSize.width, aDesiredSize.height);
// Now notify our containing block that there's a new floater
@ -91,11 +91,12 @@ PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
container->PlaceFloater(aPresContext, mAnchoredItem, this);
}
return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize);
return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, aStatus);
}
void PlaceholderFrame::ListTag(FILE* out) const
NS_METHOD PlaceholderFrame::ListTag(FILE* out) const
{
fputs("*placeholder", out);
fprintf(out, "(%d)@%p", mIndexInParent, this);
return NS_OK;
}

11
layout/generic/nsPlaceholderFrame.h
Просмотреть файл

@ -36,11 +36,12 @@ public:
nsIFrame* GetAnchoredItem() const {return mAnchoredItem;}
// Resize reflow methods
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
virtual void ListTag(FILE* out = stdout) const;
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
NS_IMETHOD ListTag(FILE* out = stdout) const;
protected:
// Constructor. Takes as arguments the content object, the index in parent,

28
layout/html/base/src/deadnsInlineFrame.h
Просмотреть файл

@ -31,22 +31,24 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
virtual void GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
NS_IMETHOD GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
protected:
nsInlineFrame(nsIContent* aContent,

31
layout/html/base/src/nsBRPart.cpp
Просмотреть файл

@ -37,12 +37,13 @@ public:
BRFrame(nsIContent* aContent,
PRInt32 aIndexInParent,
nsIFrame* aParentFrame);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
virtual void GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
NS_IMETHOD GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
protected:
virtual ~BRFrame();
@ -59,7 +60,7 @@ BRFrame::~BRFrame()
{
}
void BRFrame::GetReflowMetrics(nsIPresContext* aPresContext, nsReflowMetrics& aMetrics)
NS_METHOD BRFrame::GetReflowMetrics(nsIPresContext* aPresContext, nsReflowMetrics& aMetrics)
{
// We have no width, but we're the height of the default font
nsStyleFont* font =
@ -70,13 +71,14 @@ void BRFrame::GetReflowMetrics(nsIPresContext* aPresContext, nsReflowMetrics& aM
aMetrics.ascent = fm->GetMaxAscent();
aMetrics.descent = fm->GetMaxDescent();
NS_RELEASE(fm);
return NS_OK;
}
nsIFrame::ReflowStatus
BRFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD BRFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
// Get cached state for containing block frame
nsBlockReflowState* state = nsnull;
@ -90,7 +92,7 @@ BRFrame::ResizeReflow(nsIPresContext* aPresContext,
break;
}
}
parent = parent->GetGeometricParent();
parent->GetGeometricParent(parent);
}
if (nsnull != parent) {
nsIPresShell* shell = aPresContext->GetShell();
@ -103,7 +105,8 @@ BRFrame::ResizeReflow(nsIPresContext* aPresContext,
}
GetReflowMetrics(aPresContext, aDesiredSize);
return frComplete;
aStatus = frComplete;
return NS_OK;
}
//----------------------------------------------------------------------

292
layout/html/base/src/nsBlockFrame.cpp
Просмотреть файл

@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
#endif
@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aY);
// Get the type of floater
nsIStyleContext* styleContext = floater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
floater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
// both the line and the floaters are pushed to the next-in-flow...
}
} else {
lineHeight = aState.lineStart->GetHeight();
nsSize size;
aState.lineStart->GetSize(size);
lineHeight = size.height;
}
// The first line always fits
@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
// Update maxElementSize
@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
{
nsIFrame* prevFrame = aState.prevLineLastFrame;
NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
"bad prev line");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevFrame->GetNextSibling(nextSibling);
NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
#endif
#ifdef NS_DEBUG
PRInt32 numKids = LengthOf(mFirstChild);
@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
PRInt32 kids = 0;
while (nsnull != kid) {
kids++;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
mChildCount = kids;
@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get kid and its style
// XXX How is this any different than what was passed in to us as aKidMol?
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
nsIContent* kid;
nsIStyleContext* kidSC;
kidFrame->GetContent(kid);
kidFrame->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
if (!AdvanceToNextLine(aCX, aState)) {
@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get the style for the last child, and see if it wanted to clear floaters.
// This handles the BR tag, which is the only inline element for which clear
// applies
nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
nsIStyleContext* lastChildSC;
lastFrame->GetStyleContext(aCX, lastChildSC);
nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID);
if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
ClearFloaters(aState, lastChildMol->clear);
@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
// Reflow splittable children
if (kidFrame->IsSplittable()) {
PRBool isSplittable;
kidFrame->IsSplittable(isSplittable);
if (isSplittable) {
// Update size info now that we are on the next line. Then
// reflow the child into the new available space.
GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
nsIFrame* prevKidFrame = nsnull;
for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
}
// Is the child complete?
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (frComplete == status) {
// Yes, the child is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
} else {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
mChildCount++;
@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
// Get the next child frame
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
push_done:;
// Update the child count member data
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
push_done:
#ifdef NS_DEBUG
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
PRInt32 len = LengthOf(mFirstChild);
NS_POSTCONDITION(len == mChildCount, "bad child count");
VerifyLastIsComplete();
@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
mFirstContentOffset = prev->NextChildOffset();
if (PR_FALSE == prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
// Place our children, one at a time until we are out of children
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
} else {
// Since kid has a prev-in-flow, use that to create the next
// frame.
kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
}
// Link child frame into the list of children. If the frame ends
// up not fitting and getting pushed, the PushKids code will fixup
// the child count for us.
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// We ran out of room.
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
NS_RELEASE(kid);
@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child didn't complete so create a continuing frame
kidPrevInFlow = kidFrame;
nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to the sibling list
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
kidFrame = continuingFrame;
mChildCount++;
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
}
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
#endif
} while (frNotComplete == status);
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// The child that we just reflowed is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
#endif
kidIndex++;
kidPrevInFlow = nsnull;
}
@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
// children OR we are a pseudo-frame and we ran into a block
// element. In either case our last content MUST be complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
push_done:
@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
PRBool result = PR_TRUE;
nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
while (nsnull != nextInFlow) {
// Get first available frame from the next-in-flow
nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
}
// Get style information for the pulled up kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// Push the kids that didn't fit back down to the next-in-flow
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
result = PR_FALSE;
@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child is not complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// Create a continuing frame for the incomplete child
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to our sibling list.
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
continuingFrame->SetNextSibling(nextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
kidFrame = continuingFrame;
@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
} else {
// The child has a next-in-flow, but it's not one of ours.
// It *must* be in one of our next-in-flows. Collect it
// then.
NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
"busted kid next-in-flow");
NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
break;
}
}
@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// in our next-in-flows (and reflowing any continunations they
// have). Therefore we KNOW that our last child is complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
}
#include "nsUnitConversion.h"/* XXX */
nsIFrame::ReflowStatus
nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
nsBlockReflowState state;
SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
return DoResizeReflow(aCX, state, aDesiredRect);
return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
}
nsIFrame::ReflowStatus
nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect)
nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// First reflow any existing frames
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete;
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aCX, aState);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// unmapped. We need to return the correct completion status,
// so see if there is more to reflow.
if (MoreToReflow(aCX)) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (MoreToReflow(aCX)) {
// Try and pull-up some children from a next-in-flow
if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
// If we still have unmapped children then create some new frames
if (MoreToReflow(aCX)) {
status = ReflowAppendedChildren(aCX, aState);
aStatus = ReflowAppendedChildren(aCX, aState);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
#endif
PushKids(aState);
status = frNotComplete;
aStatus = frNotComplete;
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there is room for it.
nscoord margin = aState.prevMaxPosBottomMargin -
@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
aDesiredRect.height = aState.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
#ifdef NOISY
ListTag(stdout);
@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
DumpFlow();
#endif
mCurrentState = nsnull;
return status;
return NS_OK;
}
void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
kid->JustifyReflow(aCX, availableSpace);
kid->SizeTo(r.width + availableSpace, r.height);
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
} else {
// XXX Get justification of multiple elements working
while (--lineLength >= 0) {
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
}
@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
}
}
nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent)
NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aCX, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsIFrame::ReflowStatus
nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete;
if (aReflowCommand.GetTarget() == this) {
// XXX for now, just do a complete reflow mapped (it'll kinda
@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else {
// XXX not yet implemented
@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
}
mCurrentState = nsnull;
return status;
return NS_OK;
}
PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
{
do {
nsIFrame* parent = aFrame->GetGeometricParent();
nsIFrame* parent;
aFrame->GetGeometricParent(parent);
// See if there are any non-zero sized child frames that precede aFrame
// in the child list
nsIFrame* child = parent->FirstChild();
nsIFrame* child;
parent->FirstChild(child);
while ((nsnull != child) && (aFrame != child)) {
nsSize size;
// Is the child zero-sized?
if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
child->GetSize(size);
if ((size.width > 0) || (size.height > 0)) {
// We found a non-zero sized child frame that precedes aFrame
return PR_FALSE;
}
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// aFrame is the left-most non-zero sized frame in its geometric parent.
@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
// todo list and we'll handle it when we flush out the line
if (IsLeftMostChild(aPlaceholder)) {
// Get the type of floater
nsIStyleContext* styleContext = aFloater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
aFloater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
}
}
void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsBlockFrame* flow = this;
for (;;) {
nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last-in-flow
nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
NS_RELEASE(kidSC);
NS_RELEASE(kid);
return;
return NS_OK;
}
// FALL THROUGH (and create frame)
@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
// Link child frame into the list of children
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}
PRIntn nsBlockFrame::GetSkipSides() const
@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
return eHTMLFrame_Block;
}
void nsBlockFrame::ListTag(FILE* out) const
NS_METHOD nsBlockFrame::ListTag(FILE* out) const
{
if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
fprintf(out, "*block(%d)@%p", mIndexInParent, this);
} else {
nsHTMLContainerFrame::ListTag(out);
}
return NS_OK;
}
#ifdef NS_DEBUG

42
layout/html/base/src/nsBlockFrame.h
Просмотреть файл

@ -198,24 +198,27 @@ public:
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
virtual PRBool AddFloater(nsIPresContext* aCX,
nsIFrame* aFloater,
@ -224,7 +227,7 @@ public:
nsIFrame* aFloater,
PlaceholderFrame* aPlaceholder);
virtual void ListTag(FILE* out = stdout) const;
NS_IMETHOD ListTag(FILE* out = stdout) const;
virtual nsHTMLFrameType GetFrameType() const;
@ -277,9 +280,10 @@ protected:
const nsSize& aMaxSize, nsSize* aMaxElementSize,
nsISpaceManager* aSpaceManager);
ReflowStatus DoResizeReflow(nsIPresContext* aPresContext,
nsBlockReflowState& aState,
nsRect& aDesiredRect);
nsresult DoResizeReflow(nsIPresContext* aPresContext,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus);
PRBool ReflowMappedChildren(nsIPresContext* aPresContext,
nsBlockReflowState& aState);

292
layout/html/base/src/nsBlockReflowState.cpp
Просмотреть файл

@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
#endif
@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aY);
// Get the type of floater
nsIStyleContext* styleContext = floater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
floater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
// both the line and the floaters are pushed to the next-in-flow...
}
} else {
lineHeight = aState.lineStart->GetHeight();
nsSize size;
aState.lineStart->GetSize(size);
lineHeight = size.height;
}
// The first line always fits
@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
// Update maxElementSize
@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
{
nsIFrame* prevFrame = aState.prevLineLastFrame;
NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
"bad prev line");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevFrame->GetNextSibling(nextSibling);
NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
#endif
#ifdef NS_DEBUG
PRInt32 numKids = LengthOf(mFirstChild);
@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
PRInt32 kids = 0;
while (nsnull != kid) {
kids++;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
mChildCount = kids;
@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get kid and its style
// XXX How is this any different than what was passed in to us as aKidMol?
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
nsIContent* kid;
nsIStyleContext* kidSC;
kidFrame->GetContent(kid);
kidFrame->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
if (!AdvanceToNextLine(aCX, aState)) {
@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get the style for the last child, and see if it wanted to clear floaters.
// This handles the BR tag, which is the only inline element for which clear
// applies
nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
nsIStyleContext* lastChildSC;
lastFrame->GetStyleContext(aCX, lastChildSC);
nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID);
if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
ClearFloaters(aState, lastChildMol->clear);
@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
// Reflow splittable children
if (kidFrame->IsSplittable()) {
PRBool isSplittable;
kidFrame->IsSplittable(isSplittable);
if (isSplittable) {
// Update size info now that we are on the next line. Then
// reflow the child into the new available space.
GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
nsIFrame* prevKidFrame = nsnull;
for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
}
// Is the child complete?
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (frComplete == status) {
// Yes, the child is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
} else {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
mChildCount++;
@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
// Get the next child frame
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
push_done:;
// Update the child count member data
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
push_done:
#ifdef NS_DEBUG
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
PRInt32 len = LengthOf(mFirstChild);
NS_POSTCONDITION(len == mChildCount, "bad child count");
VerifyLastIsComplete();
@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
mFirstContentOffset = prev->NextChildOffset();
if (PR_FALSE == prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
// Place our children, one at a time until we are out of children
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
} else {
// Since kid has a prev-in-flow, use that to create the next
// frame.
kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
}
// Link child frame into the list of children. If the frame ends
// up not fitting and getting pushed, the PushKids code will fixup
// the child count for us.
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// We ran out of room.
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
NS_RELEASE(kid);
@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child didn't complete so create a continuing frame
kidPrevInFlow = kidFrame;
nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to the sibling list
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
kidFrame = continuingFrame;
mChildCount++;
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
}
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
#endif
} while (frNotComplete == status);
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// The child that we just reflowed is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
#endif
kidIndex++;
kidPrevInFlow = nsnull;
}
@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
// children OR we are a pseudo-frame and we ran into a block
// element. In either case our last content MUST be complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
push_done:
@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
PRBool result = PR_TRUE;
nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
while (nsnull != nextInFlow) {
// Get first available frame from the next-in-flow
nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
}
// Get style information for the pulled up kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// Push the kids that didn't fit back down to the next-in-flow
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
result = PR_FALSE;
@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child is not complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// Create a continuing frame for the incomplete child
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to our sibling list.
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
continuingFrame->SetNextSibling(nextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
kidFrame = continuingFrame;
@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
} else {
// The child has a next-in-flow, but it's not one of ours.
// It *must* be in one of our next-in-flows. Collect it
// then.
NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
"busted kid next-in-flow");
NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
break;
}
}
@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// in our next-in-flows (and reflowing any continunations they
// have). Therefore we KNOW that our last child is complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
}
#include "nsUnitConversion.h"/* XXX */
nsIFrame::ReflowStatus
nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
nsBlockReflowState state;
SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
return DoResizeReflow(aCX, state, aDesiredRect);
return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
}
nsIFrame::ReflowStatus
nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect)
nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// First reflow any existing frames
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete;
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aCX, aState);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// unmapped. We need to return the correct completion status,
// so see if there is more to reflow.
if (MoreToReflow(aCX)) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (MoreToReflow(aCX)) {
// Try and pull-up some children from a next-in-flow
if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
// If we still have unmapped children then create some new frames
if (MoreToReflow(aCX)) {
status = ReflowAppendedChildren(aCX, aState);
aStatus = ReflowAppendedChildren(aCX, aState);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
#endif
PushKids(aState);
status = frNotComplete;
aStatus = frNotComplete;
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there is room for it.
nscoord margin = aState.prevMaxPosBottomMargin -
@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
aDesiredRect.height = aState.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
#ifdef NOISY
ListTag(stdout);
@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
DumpFlow();
#endif
mCurrentState = nsnull;
return status;
return NS_OK;
}
void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
kid->JustifyReflow(aCX, availableSpace);
kid->SizeTo(r.width + availableSpace, r.height);
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
} else {
// XXX Get justification of multiple elements working
while (--lineLength >= 0) {
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
}
@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
}
}
nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent)
NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aCX, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsIFrame::ReflowStatus
nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete;
if (aReflowCommand.GetTarget() == this) {
// XXX for now, just do a complete reflow mapped (it'll kinda
@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else {
// XXX not yet implemented
@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
}
mCurrentState = nsnull;
return status;
return NS_OK;
}
PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
{
do {
nsIFrame* parent = aFrame->GetGeometricParent();
nsIFrame* parent;
aFrame->GetGeometricParent(parent);
// See if there are any non-zero sized child frames that precede aFrame
// in the child list
nsIFrame* child = parent->FirstChild();
nsIFrame* child;
parent->FirstChild(child);
while ((nsnull != child) && (aFrame != child)) {
nsSize size;
// Is the child zero-sized?
if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
child->GetSize(size);
if ((size.width > 0) || (size.height > 0)) {
// We found a non-zero sized child frame that precedes aFrame
return PR_FALSE;
}
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// aFrame is the left-most non-zero sized frame in its geometric parent.
@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
// todo list and we'll handle it when we flush out the line
if (IsLeftMostChild(aPlaceholder)) {
// Get the type of floater
nsIStyleContext* styleContext = aFloater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
aFloater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
}
}
void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsBlockFrame* flow = this;
for (;;) {
nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last-in-flow
nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
NS_RELEASE(kidSC);
NS_RELEASE(kid);
return;
return NS_OK;
}
// FALL THROUGH (and create frame)
@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
// Link child frame into the list of children
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}
PRIntn nsBlockFrame::GetSkipSides() const
@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
return eHTMLFrame_Block;
}
void nsBlockFrame::ListTag(FILE* out) const
NS_METHOD nsBlockFrame::ListTag(FILE* out) const
{
if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
fprintf(out, "*block(%d)@%p", mIndexInParent, this);
} else {
nsHTMLContainerFrame::ListTag(out);
}
return NS_OK;
}
#ifdef NS_DEBUG

292
layout/html/base/src/nsBlockReflowState.h
Просмотреть файл

@ -221,7 +221,7 @@ void nsBlockReflowState::DumpLine()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
@ -232,7 +232,7 @@ void nsBlockReflowState::DumpList()
printf(" ");
((nsFrame*)f)->ListTag(stdout);/* XXX */
printf("\n");
f = f->GetNextSibling();
f->GetNextSibling(f);
}
}
#endif
@ -335,7 +335,9 @@ void nsBlockFrame::PlaceBelowCurrentLineFloaters(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aY);
// Get the type of floater
nsIStyleContext* styleContext = floater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
floater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -394,7 +396,10 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
// both the line and the floaters are pushed to the next-in-flow...
}
} else {
lineHeight = aState.lineStart->GetHeight();
nsSize size;
aState.lineStart->GetSize(size);
lineHeight = size.height;
}
// The first line always fits
@ -447,7 +452,7 @@ PRBool nsBlockFrame::AdvanceToNextLine(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
// Update maxElementSize
@ -663,8 +668,12 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
{
nsIFrame* prevFrame = aState.prevLineLastFrame;
NS_PRECONDITION(nsnull != prevFrame, "pushing all kids");
NS_PRECONDITION(prevFrame->GetNextSibling() == aState.lineStart,
"bad prev line");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevFrame->GetNextSibling(nextSibling);
NS_PRECONDITION(nextSibling == aState.lineStart, "bad prev line");
#endif
#ifdef NS_DEBUG
PRInt32 numKids = LengthOf(mFirstChild);
@ -692,7 +701,7 @@ void nsBlockFrame::PushKids(nsBlockReflowState& aState)
PRInt32 kids = 0;
while (nsnull != kid) {
kids++;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
mChildCount = kids;
@ -823,8 +832,11 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get kid and its style
// XXX How is this any different than what was passed in to us as aKidMol?
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aCX);
nsIContent* kid;
nsIStyleContext* kidSC;
kidFrame->GetContent(kid);
kidFrame->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -854,7 +866,7 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
nsIFrame* lastFrame = aState.lineStart;
PRInt32 lineLen = aState.lineLength - 1;
while (--lineLen >= 0) {
lastFrame = lastFrame->GetNextSibling();
lastFrame->GetNextSibling(lastFrame);
}
if (!AdvanceToNextLine(aCX, aState)) {
@ -866,7 +878,9 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// Get the style for the last child, and see if it wanted to clear floaters.
// This handles the BR tag, which is the only inline element for which clear
// applies
nsIStyleContext* lastChildSC = lastFrame->GetStyleContext(aCX);
nsIStyleContext* lastChildSC;
lastFrame->GetStyleContext(aCX, lastChildSC);
nsStyleMolecule* lastChildMol = (nsStyleMolecule*)lastChildSC->GetData(kStyleMoleculeSID);
if (lastChildMol->clear != NS_STYLE_CLEAR_NONE) {
ClearFloaters(aState, lastChildMol->clear);
@ -964,7 +978,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
GetAvailableSpaceBand(aState, aState.y + aState.topMargin);
// Reflow splittable children
if (kidFrame->IsSplittable()) {
PRBool isSplittable;
kidFrame->IsSplittable(isSplittable);
if (isSplittable) {
// Update size info now that we are on the next line. Then
// reflow the child into the new available space.
GetAvailSize(kidAvailSize, aState, kidMol, PR_TRUE);
@ -973,7 +990,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1042,7 +1062,10 @@ nsBlockFrame::PlaceAndReflowChild(nsIPresContext* aCX,
// If we just reflowed our last child then update the
// mLastContentIsComplete state.
if (nsnull == kidFrame->GetNextSibling()) {
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull == nextSibling) {
// Use state from the reflow we just did
mLastContentIsComplete = PRBool(status == frComplete);
}
@ -1091,7 +1114,9 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
nsIFrame* prevKidFrame = nsnull;
for (kidFrame = mFirstChild; nsnull != kidFrame; ) {
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
@ -1113,21 +1138,26 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
}
// Is the child complete?
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (frComplete == status) {
// Yes, the child is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
} else {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
mChildCount++;
@ -1141,14 +1171,18 @@ nsBlockFrame::ReflowMappedChildren(nsIPresContext* aCX,
// Get the next child frame
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
push_done:;
// Update the child count member data
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
push_done:
#ifdef NS_DEBUG
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
PRInt32 len = LengthOf(mFirstChild);
NS_POSTCONDITION(len == mChildCount, "bad child count");
VerifyLastIsComplete();
@ -1224,14 +1258,16 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
mFirstContentOffset = prev->NextChildOffset();
if (PR_FALSE == prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
// Place our children, one at a time until we are out of children
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1289,14 +1325,19 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
} else {
// Since kid has a prev-in-flow, use that to create the next
// frame.
kidFrame = kidPrevInFlow->CreateContinuingFrame(aCX, this);
kidPrevInFlow->CreateContinuingFrame(aCX, this, kidFrame);
}
// Link child frame into the list of children. If the frame ends
// up not fitting and getting pushed, the PushKids code will fixup
// the child count for us.
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1314,7 +1355,10 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// We ran out of room.
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
NS_RELEASE(kid);
@ -1327,26 +1371,41 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child didn't complete so create a continuing frame
kidPrevInFlow = kidFrame;
nsIFrame* continuingFrame = kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to the sibling list
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
kidFrame = continuingFrame;
mChildCount++;
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
}
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "huh?");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "huh?");
#endif
} while (frNotComplete == status);
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// The child that we just reflowed is complete
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
#ifdef NS_DEBUG
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
#endif
kidIndex++;
kidPrevInFlow = nsnull;
}
@ -1356,8 +1415,7 @@ nsBlockFrame::ReflowAppendedChildren(nsIPresContext* aCX,
// children OR we are a pseudo-frame and we ran into a block
// element. In either case our last content MUST be complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
push_done:
@ -1395,7 +1453,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
PRBool result = PR_TRUE;
nsBlockFrame* nextInFlow = (nsBlockFrame*) mNextInFlow;
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
while (nsnull != nextInFlow) {
// Get first available frame from the next-in-flow
nsIFrame* kidFrame = PullUpOneChild(nextInFlow, prevKidFrame);
@ -1407,7 +1467,9 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
}
// Get style information for the pulled up kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC = aCX->ResolveStyleContextFor(kid, this);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
@ -1417,7 +1479,10 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
status = aState.reflowStatus;
if (0 == (placeStatus & PLACE_FIT)) {
// Push the kids that didn't fit back down to the next-in-flow
mLastContentIsComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
mLastContentIsComplete = PRBool(nsnull == kidNextInFlow);
PushKids(aState);
result = PR_FALSE;
@ -1428,14 +1493,20 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
if (frNotComplete == status) {
// Child is not complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// Create a continuing frame for the incomplete child
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aCX, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aCX, this, continuingFrame);
// Add the continuing frame to our sibling list.
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
continuingFrame->SetNextSibling(nextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
kidFrame = continuingFrame;
@ -1443,14 +1514,13 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// Switch to new kid style
NS_RELEASE(kidSC);
kidSC = kidFrame->GetStyleContext(aCX);
kidFrame->GetStyleContext(aCX, kidSC);
kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
} else {
// The child has a next-in-flow, but it's not one of ours.
// It *must* be in one of our next-in-flows. Collect it
// then.
NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
"busted kid next-in-flow");
NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
break;
}
}
@ -1466,7 +1536,7 @@ nsBlockFrame::PullUpChildren(nsIPresContext* aCX,
// in our next-in-flows (and reflowing any continunations they
// have). Therefore we KNOW that our last child is complete.
NS_ASSERTION(PR_TRUE == aState.lastContentIsComplete, "bad state");
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1546,22 +1616,22 @@ void nsBlockFrame::SetupState(nsIPresContext* aCX,
}
#include "nsUnitConversion.h"/* XXX */
nsIFrame::ReflowStatus
nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD nsBlockFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
nsBlockReflowState state;
SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
return DoResizeReflow(aCX, state, aDesiredRect);
return DoResizeReflow(aCX, state, aDesiredRect, aStatus);
}
nsIFrame::ReflowStatus
nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect)
nsresult nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
nsBlockReflowState& aState,
nsRect& aDesiredRect,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -1591,11 +1661,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// First reflow any existing frames
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete;
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aCX, aState);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -1607,19 +1677,19 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
// unmapped. We need to return the correct completion status,
// so see if there is more to reflow.
if (MoreToReflow(aCX)) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (MoreToReflow(aCX)) {
// Try and pull-up some children from a next-in-flow
if ((nsnull == mNextInFlow) || PullUpChildren(aCX, aState)) {
// If we still have unmapped children then create some new frames
if (MoreToReflow(aCX)) {
status = ReflowAppendedChildren(aCX, aState);
aStatus = ReflowAppendedChildren(aCX, aState);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -1638,11 +1708,11 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
#endif
PushKids(aState);
status = frNotComplete;
aStatus = frNotComplete;
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there is room for it.
nscoord margin = aState.prevMaxPosBottomMargin -
@ -1689,7 +1759,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
aDesiredRect.height = aState.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
#ifdef NOISY
ListTag(stdout);
@ -1703,7 +1773,7 @@ nsBlockFrame::DoResizeReflow(nsIPresContext* aCX,
DumpFlow();
#endif
mCurrentState = nsnull;
return status;
return NS_OK;
}
void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
@ -1732,11 +1802,11 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
kid->JustifyReflow(aCX, availableSpace);
kid->SizeTo(r.width + availableSpace, r.height);
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
} else {
// XXX Get justification of multiple elements working
while (--lineLength >= 0) {
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
}
@ -1748,22 +1818,24 @@ void nsBlockFrame::JustifyLines(nsIPresContext* aCX,
}
}
nsIFrame* nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent)
NS_METHOD nsBlockFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsBlockFrame* cf = new nsBlockFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aCX, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsIFrame::ReflowStatus
nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete;
if (aReflowCommand.GetTarget() == this) {
// XXX for now, just do a complete reflow mapped (it'll kinda
@ -1773,7 +1845,7 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
SetupState(aCX, state, aMaxSize, nsnull, aSpaceManager);
PRBool reflowMappedOK = ReflowMappedChildren(aCX, state);
if (!reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else {
// XXX not yet implemented
@ -1786,26 +1858,32 @@ nsBlockFrame::IncrementalReflow(nsIPresContext* aCX,
}
mCurrentState = nsnull;
return status;
return NS_OK;
}
PRBool nsBlockFrame::IsLeftMostChild(nsIFrame* aFrame)
{
do {
nsIFrame* parent = aFrame->GetGeometricParent();
nsIFrame* parent;
aFrame->GetGeometricParent(parent);
// See if there are any non-zero sized child frames that precede aFrame
// in the child list
nsIFrame* child = parent->FirstChild();
nsIFrame* child;
parent->FirstChild(child);
while ((nsnull != child) && (aFrame != child)) {
nsSize size;
// Is the child zero-sized?
if ((child->GetWidth() > 0) || (child->GetHeight() > 0)) {
child->GetSize(size);
if ((size.width > 0) || (size.height > 0)) {
// We found a non-zero sized child frame that precedes aFrame
return PR_FALSE;
}
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// aFrame is the left-most non-zero sized frame in its geometric parent.
@ -1848,7 +1926,9 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
// todo list and we'll handle it when we flush out the line
if (IsLeftMostChild(aPlaceholder)) {
// Get the type of floater
nsIStyleContext* styleContext = aFloater->GetStyleContext(aCX);
nsIStyleContext* styleContext;
aFloater->GetStyleContext(aCX, styleContext);
nsStyleMolecule* mol = (nsStyleMolecule*)styleContext->GetData(kStyleMoleculeSID);
NS_RELEASE(styleContext);
@ -1889,24 +1969,19 @@ void nsBlockFrame::PlaceFloater(nsIPresContext* aCX,
}
}
void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsBlockFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsBlockFrame* flow = this;
for (;;) {
nsBlockFrame* next = (nsBlockFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last-in-flow
nsBlockFrame* flow = (nsBlockFrame*)GetLastInFlow();
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* kidFrame = nsnull;
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1943,7 +2018,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
NS_RELEASE(kidSC);
NS_RELEASE(kid);
return;
return NS_OK;
}
// FALL THROUGH (and create frame)
@ -1964,7 +2039,12 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
// Link child frame into the list of children
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* nextSibling;
prevKidFrame->GetNextSibling(nextSibling);
NS_ASSERTION(nsnull == nextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -1986,6 +2066,7 @@ void nsBlockFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}
PRIntn nsBlockFrame::GetSkipSides() const
@ -2005,13 +2086,14 @@ nsHTMLFrameType nsBlockFrame::GetFrameType() const
return eHTMLFrame_Block;
}
void nsBlockFrame::ListTag(FILE* out) const
NS_METHOD nsBlockFrame::ListTag(FILE* out) const
{
if ((nsnull != mGeometricParent) && IsPseudoFrame()) {
fprintf(out, "*block(%d)@%p", mIndexInParent, this);
} else {
nsHTMLContainerFrame::ListTag(out);
}
return NS_OK;
}
#ifdef NS_DEBUG

82
layout/html/base/src/nsBodyFrame.cpp
Просмотреть файл

@ -98,7 +98,7 @@ void nsBodyFrame::CreateColumnFrame(nsIPresContext* aPresContext)
NS_ASSERTION(prevBody->ChildIsPseudoFrame(prevColumn), "bad previous column");
// Create a continuing column
mFirstChild = prevColumn->CreateContinuingFrame(aPresContext, this);
prevColumn->CreateContinuingFrame(aPresContext, this, mFirstChild);
mChildCount = 1;
}
}
@ -130,13 +130,13 @@ nsSize nsBodyFrame::GetColumnAvailSpace(nsIPresContext* aPresContext,
return result;
}
nsIFrame::ReflowStatus
nsBodyFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsBodyFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
nsIFrame::ReflowStatus status = frComplete;
aStatus = frComplete; // initialize out parameter
// Do we have any children?
if (nsnull == mFirstChild) {
@ -168,8 +168,8 @@ nsBodyFrame::ResizeReflow(nsIPresContext* aPresContext,
nsRect desiredRect;
mSpaceManager->Translate(leftInset, topInset);
status = ReflowChild(mFirstChild, aPresContext, mSpaceManager, columnMaxSize,
desiredRect, aMaxElementSize);
aStatus = ReflowChild(mFirstChild, aPresContext, mSpaceManager, columnMaxSize,
desiredRect, aMaxElementSize);
mSpaceManager->Translate(-leftInset, -topInset);
// Place and size the column
@ -193,16 +193,18 @@ nsBodyFrame::ResizeReflow(nsIPresContext* aPresContext,
aDesiredSize.descent = 0;
}
return status;
return NS_OK;
}
void nsBodyFrame::VerifyTree() const
NS_METHOD nsBodyFrame::VerifyTree() const
{
#ifdef NS_DEBUG
// Check our child count
PRInt32 len = LengthOf(mFirstChild);
NS_ASSERTION(len == mChildCount, "bad child count");
nsIFrame* lastChild = LastChild();
nsIFrame* lastChild;
LastChild(lastChild);
if (len != 0) {
NS_ASSERTION(nsnull != lastChild, "bad last child");
}
@ -217,7 +219,7 @@ void nsBodyFrame::VerifyTree() const
while (nsnull != child) {
// Make sure that the child's tree is valid
child->VerifyTree();
child = child->GetNextSibling();
child->GetNextSibling(child);
}
// Make sure that our flow blocks offsets are all correct
@ -233,16 +235,15 @@ void nsBodyFrame::VerifyTree() const
}
}
#endif
return NS_OK;
}
nsIFrame::ReflowStatus
nsBodyFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsBodyFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status;
// Get our border/padding info
nsStyleMolecule* myMol =
(nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@ -276,8 +277,8 @@ nsBodyFrame::IncrementalReflow(nsIPresContext* aPresContext,
NS_ASSERTION(nsnull != mFirstChild, "no first child");
mFirstChild->QueryInterface(kIRunaroundIID, (void**)&reflowRunaround);
status = reflowRunaround->IncrementalReflow(aPresContext, mSpaceManager,
columnMaxSize, aDesiredRect, aReflowCommand);
reflowRunaround->IncrementalReflow(aPresContext, mSpaceManager,
columnMaxSize, aDesiredRect, aReflowCommand, aStatus);
// Place and size the column
aDesiredRect.x += leftInset;
@ -302,7 +303,7 @@ nsBodyFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsRect desiredRect;
nsIFrame* child;
status = aReflowCommand.Next(mSpaceManager, desiredRect, aMaxSize, child);
aStatus = aReflowCommand.Next(mSpaceManager, desiredRect, aMaxSize, child);
// XXX Deal with next in flow, adjusting of siblings, adjusting the
// content length...
@ -315,24 +316,17 @@ nsBodyFrame::IncrementalReflow(nsIPresContext* aPresContext,
}
mSpaceManager->Translate(-leftInset, -topInset);
return status;
return NS_OK;
}
void nsBodyFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsBodyFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
NS_ASSERTION(mContent == aContainer, "bad content-appended target");
// Zip down to the end-of-flow
nsBodyFrame* flow = this;
for (;;) {
nsBodyFrame* next = (nsBodyFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last-in-flow
nsBodyFrame* flow = (nsBodyFrame*)GetLastInFlow();
// Since body frame's have only a single pseudo-frame in them,
// pass on the content-appended call to the pseudo-frame
@ -344,6 +338,7 @@ void nsBodyFrame::ContentAppended(nsIPresShell* aShell,
new nsReflowCommand(aPresContext, flow, nsReflowCommand::FrameAppended,
oldLastContentOffset);
aShell->AppendReflowCommand(rc);
return NS_OK;
}
void nsBodyFrame::AddAnchoredItem(nsIFrame* aAnchoredItem,
@ -352,26 +347,31 @@ void nsBodyFrame::AddAnchoredItem(nsIFrame* aAnchoredItem,
{
aAnchoredItem->SetGeometricParent(this);
// Add the item to the end of the child list
LastChild()->SetNextSibling(aAnchoredItem);
nsIFrame* lastChild;
LastChild(lastChild);
lastChild->SetNextSibling(aAnchoredItem);
aAnchoredItem->SetNextSibling(nsnull);
mChildCount++;
}
void nsBodyFrame::RemoveAnchoredItem(nsIFrame* aAnchoredItem)
{
NS_PRECONDITION(this == aAnchoredItem->GetGeometricParent(), "bad anchored item");
NS_PRECONDITION(IsChild(aAnchoredItem), "bad anchored item");
NS_ASSERTION(aAnchoredItem != mFirstChild, "unexpected anchored item");
// Remove the anchored item from the child list
// XXX Implement me
mChildCount--;
}
nsIFrame* nsBodyFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsBodyFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsBodyFrame* cf = new nsBodyFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
// XXX use same logic as block frame?

31
layout/html/base/src/nsBodyFrame.h
Просмотреть файл

@ -33,22 +33,25 @@ public:
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
virtual void AddAnchoredItem(nsIFrame* aAnchoredItem,
AnchoringPosition aPosition,
@ -56,7 +59,7 @@ public:
virtual void RemoveAnchoredItem(nsIFrame* aAnchoredItem);
virtual void VerifyTree() const;
NS_IMETHOD VerifyTree() const;
protected:
nsBodyFrame(nsIContent* aContent,

200
layout/html/base/src/nsColumnFrame.cpp
Просмотреть файл

@ -226,12 +226,12 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
nsIFrame::ReflowStatus status;
// Get top margin for this kid
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// Figure out the amount of available size for the child (subtract
@ -297,15 +297,20 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
if (frNotComplete == status) {
// XXX It's good to assume that we might still have room
// even if the child didn't complete (floaters will want this)
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// No the child isn't complete, and it doesn't have a next in flow so
// create a continuing frame. This hooks the child into the flow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
// Insert the frame. We'll reflow it next pass through the loop
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -319,7 +324,7 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
// Get the next child
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
// XXX talk with troy about checking for available space here
}
@ -329,7 +334,7 @@ PRBool ColumnFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
// Set the last content offset based on the last child we mapped.
NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
@ -397,7 +402,9 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
// The frame previous to the current frame we are reflowing. This
// starts out initially as our last frame.
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -421,8 +428,9 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
}
// Get top margin for this kid
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
@ -443,8 +451,8 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
// out of space.
if ((kidFrame == mFirstChild) || (kidAvailSize.height > 0)) {
aState.spaceManager->Translate(kidMol->margin.left, topMargin);
status = ReflowChild(kidFrame, aPresContext, aState.spaceManager,
kidAvailSize, kidRect, pKidMaxElementSize);
status = ReflowChild(kidFrame, aPresContext, aState.spaceManager, kidAvailSize,
kidRect, pKidMaxElementSize);
aState.spaceManager->Translate(-kidMol->margin.left, -topMargin);
}
@ -458,12 +466,14 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
//
// Note that if the width is too big that's okay and we allow the
// child to extend horizontally outside of the reflow area
PRBool lastComplete = PRBool(nsnull == kidFrame->GetNextInFlow());
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastComplete = PRBool(nsnull == kidNextInFlow);
PushChildren(kidFrame, prevKidFrame, lastComplete);
mLastContentIsComplete = prevLastContentIsComplete;
mChildCount--;
result = PR_FALSE;
NS_RELEASE(kid);
NS_RELEASE(kidSC);
goto push_done;
}
@ -492,16 +502,22 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
// Is the child we just pulled up complete?
if (frNotComplete == status) {
// No the child isn't complete.
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
// Add the continuing frame to our sibling list.
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
prevLastContentIsComplete = mLastContentIsComplete;
@ -511,13 +527,11 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
// The child has a next-in-flow, but it's not one of ours.
// It *must* be in one of our next-in-flows. Collect it
// then.
NS_ASSERTION(kidNextInFlow->GetGeometricParent() != this,
"busted kid next-in-flow");
NS_ASSERTION(!IsChild(kidNextInFlow), "busted kid next-in-flow");
break;
}
}
} while (frNotComplete == status);
NS_RELEASE(kid);
NS_RELEASE(kidSC);
prevKidFrame = kidFrame;
@ -527,7 +541,7 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
push_done:;
// Update our last content index
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -547,7 +561,7 @@ PRBool ColumnFrame::PullUpChildren(nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (ColumnFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
}
#endif
}
@ -609,7 +623,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
mFirstContentOffset = prev->NextChildOffset();
if (!prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
@ -619,7 +633,9 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsSize kidMaxElementSize;
nsSize* pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild(); // XXX remember this...
nsIFrame* prevKidFrame;
LastChild(prevKidFrame); // XXX remember this...
for (;;) {
// Get the next content object
@ -681,7 +697,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
}
kidFrame->SetStyleContext(kidStyleContext);
} else {
kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
if (ChildIsPseudoFrame(kidFrame)) {
pseudoFrame = (nsBlockFrame*) kidFrame;
}
@ -690,7 +706,12 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
// Link the child frame into the list of children and update the
// child count
if (nsnull != prevKidFrame) {
NS_ASSERTION(nsnull == prevKidFrame->GetNextSibling(), "bad append");
#ifdef NS_DEBUG
nsIFrame* prevNextSibling;
prevKidFrame->GetNextSibling(prevNextSibling);
NS_ASSERTION(nsnull == prevNextSibling, "bad append");
#endif
prevKidFrame->SetNextSibling(kidFrame);
} else {
NS_ASSERTION(nsnull == mFirstChild, "bad create");
@ -731,7 +752,12 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
NS_ASSERTION(nsnull == mNextInFlow, "whoops");
// Chop off the part of our child list that's being overflowed
NS_ASSERTION(prevKidFrame->GetNextSibling() == kidFrame, "bad list");
#ifdef NS_DEBUG
nsIFrame* prevNextSibling;
prevKidFrame->GetNextSibling(prevNextSibling);
NS_ASSERTION(prevNextSibling == kidFrame, "bad list");
#endif
prevKidFrame->SetNextSibling(nsnull);
// Create overflow list
@ -743,7 +769,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsIFrame* f = kidFrame;
while (nsnull != f) {
overflowKids++;
f = f->GetNextSibling();
f->GetNextSibling(f);
}
mChildCount -= overflowKids;
NS_RELEASE(kidStyleContext);
@ -774,11 +800,15 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
if (frNotComplete == status) {
// Child didn't complete so create a continuing frame
kidPrevInFlow = kidFrame;
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
// Add the continuing frame to the sibling list
continuingFrame->SetNextSibling(kidFrame->GetNextSibling());
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
continuingFrame->SetNextSibling(kidNextSibling);
kidFrame->SetNextSibling(continuingFrame);
prevKidFrame = kidFrame;
kidFrame = continuingFrame;
@ -810,7 +840,7 @@ ColumnFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
done:
// Update the content mapping
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
if (0 != mChildCount) {
SetLastContentOffset(prevKidFrame);
}
@ -822,12 +852,12 @@ done:
return result;
}
nsIFrame::ReflowStatus
ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -838,7 +868,8 @@ ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
//XXX NS_PRECONDITION((aMaxSize.width > 0) && (aMaxSize.height > 0), "unexpected max size");
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete; // initialize out parameter
// Initialize out parameter
if (nsnull != aMaxElementSize) {
@ -859,7 +890,7 @@ ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
reflowMappedOK =
ReflowMappedChildren(aPresContext, state, aMaxElementSize);
if (PR_FALSE == reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -869,7 +900,7 @@ ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
if ((nsnull != mFirstChild) && (state.availSize.height <= 0)) {
// No space left. Don't try to pull-up children or reflow unmapped
if (NextChildOffset() < mContent->ChildCount()) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (NextChildOffset() < mContent->ChildCount()) {
// Try and pull-up some children from a next-in-flow
@ -877,13 +908,13 @@ ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
PullUpChildren(aPresContext, state, aMaxElementSize)) {
// If we still have unmapped children then create some new frames
if (NextChildOffset() < mContent->ChildCount()) {
status =
aStatus =
ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -891,7 +922,7 @@ ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
// Restore the coordinate space
aSpaceManager->Translate(0, -state.y);
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there's room for it.
nscoord margin = state.prevMaxPosBottomMargin -
@ -914,7 +945,7 @@ ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
}
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
// Verify we properly restored the coordinate space
nscoord txOut, tyOut;
@ -922,21 +953,20 @@ ColumnFrame::ResizeReflow(nsIPresContext* aPresContext,
aSpaceManager->GetTranslation(txOut, tyOut);
NS_POSTCONDITION((txIn == txOut) && (tyIn == tyOut), "bad translation");
#endif
return status;
return NS_OK;
}
nsIFrame::ReflowStatus
ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
nscoord txIn, tyIn;
aSpaceManager->GetTranslation(txIn, tyIn);
#endif
ReflowStatus status;
// Who's the reflow command targeted for?
if (aReflowCommand.GetTarget() == mGeometricParent) {
@ -970,12 +1000,15 @@ ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
break;
}
} else {
if (kidFrame->GetIndexInParent() == startOffset) {
PRInt32 kidIndexInParent;
kidFrame->GetIndexInParent(kidIndexInParent);
if (kidIndexInParent == startOffset) {
break;
}
}
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
// Factor in the previous kid's bottom margin information
@ -988,12 +1021,12 @@ ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
prevKidFrame->GetRect(startKidRect);
// Get style info
nsIContent* kid = prevKidFrame->GetContent();
nsIStyleContext* kidSC = prevKidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
prevKidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol =
(nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord bottomMargin = kidMol->margin.bottom;
NS_RELEASE(kid);
NS_RELEASE(kidSC);
state.y = startKidRect.YMost();
@ -1004,12 +1037,12 @@ ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
}
} else {
// Get style info
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol =
(nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = kidMol->margin.top;
NS_RELEASE(kid);
NS_RELEASE(kidSC);
// Initialize y to start after the top margin
@ -1029,11 +1062,11 @@ ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
// Now ResizeReflow the appended frames
while (nsnull != kidFrame) {
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol =
(nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
NS_RELEASE(kid);
nsRect kidRect;
nsSize kidAvailSize(state.availSize);
@ -1043,8 +1076,8 @@ ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
// Reflow the child
state.spaceManager->Translate(kidMol->margin.left, 0);
status = ReflowChild(kidFrame, aPresContext, state.spaceManager,
kidAvailSize, kidRect, nsnull);
aStatus = ReflowChild(kidFrame, aPresContext, state.spaceManager,
kidAvailSize, kidRect, nsnull);
state.spaceManager->Translate(-kidMol->margin.left, 0);
// Did it fit?
@ -1074,13 +1107,13 @@ ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
NS_RELEASE(kidSC);
// XXX Was it complete?
if (frNotComplete == status) {
if (frNotComplete == aStatus) {
// XXX Need to push remaining frames and trigger a reflow there
NS_ABORT();
}
prevKidFrame = kidFrame;
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
SetLastContentOffset(prevKidFrame);
@ -1110,13 +1143,13 @@ ColumnFrame::IncrementalReflow(nsIPresContext* aPresContext,
aSpaceManager->GetTranslation(txOut, tyOut);
NS_POSTCONDITION((txIn == txOut) && (tyIn == tyOut), "bad translation");
#endif
return status;
return NS_OK;
}
// XXX factor nicely with reflow-unmapped
void ColumnFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD ColumnFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// We must only be called by the body frame since we are a
// pseudo-frame; the body frame makes sure that it's dealing with
@ -1127,9 +1160,10 @@ void ColumnFrame::ContentAppended(nsIPresShell* aShell,
// Get index of where the content has been appended
PRInt32 kidIndex = NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = LastChild();
nsIContent* content = mContent;
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
nsBlockFrame* pseudoFrame = nsnull;
if ((nsnull != prevKidFrame) && ChildIsPseudoFrame(prevKidFrame)) {
pseudoFrame = (nsBlockFrame*) prevKidFrame;
@ -1249,14 +1283,17 @@ void ColumnFrame::ContentAppended(nsIPresShell* aShell,
SetLastContentOffset(prevKidFrame);
// Note: Column frames *never* directly generate reflow commands
// because they are always pseudo-frames for bodies.
return NS_OK;
}
nsIFrame* ColumnFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD ColumnFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
ColumnFrame* cf = new ColumnFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
PRIntn ColumnFrame::GetSkipSides() const
@ -1266,8 +1303,9 @@ PRIntn ColumnFrame::GetSkipSides() const
return 0x0F;
}
void ColumnFrame::ListTag(FILE* out) const
NS_METHOD ColumnFrame::ListTag(FILE* out) const
{
fprintf(out, "*COLUMN@%p", this);
return NS_OK;
}

35
layout/html/base/src/nsColumnFrame.h
Просмотреть файл

@ -31,27 +31,30 @@ public:
NS_IMETHOD QueryInterface(const nsIID& aIID, void** aInstancePtr);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual void ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
NS_IMETHOD ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
// Debugging
virtual void ListTag(FILE* out = stdout) const;
NS_IMETHOD ListTag(FILE* out = stdout) const;
protected:
~ColumnFrame();

13
layout/html/base/src/nsHRPart.cpp
Просмотреть файл

@ -73,9 +73,9 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParentFrame);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_METHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
protected:
virtual ~HRuleFrame();
@ -109,9 +109,9 @@ HRuleFrame::~HRuleFrame()
{
}
void HRuleFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD HRuleFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
float p2t = aPresContext.GetPixelsToTwips();
nscoord thickness = nscoord(p2t * ((HRulePart*)mContent)->mThickness);
@ -197,6 +197,7 @@ void HRuleFrame::Paint(nsIPresContext& aPresContext,
width - diameter, height);
}
}
return NS_OK;
}
// Weird color computing code stolen from winfe which was stolen

35
layout/html/base/src/nsHTMLContainerFrame.cpp
Просмотреть файл

@ -44,10 +44,9 @@ nsHTMLContainerFrame::~nsHTMLContainerFrame()
{
}
void
nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// Do not paint ourselves if we are a pseudo-frame
if (PR_FALSE == IsPseudoFrame()) {
@ -68,6 +67,7 @@ nsHTMLContainerFrame::Paint(nsIPresContext& aPresContext,
aRenderingContext.SetColor(NS_RGB(255,0,0));
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
}
return NS_OK;
}
void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
@ -96,14 +96,15 @@ void nsHTMLContainerFrame::TriggerLink(nsIPresContext& aPresContext,
}
}
nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent)
NS_METHOD nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
nsEventStatus rv = nsEventStatus_eIgnore;
aEventStatus = nsEventStatus_eIgnore;
switch (aEvent->message) {
case NS_MOUSE_LEFT_BUTTON_UP:
if (nsEventStatus_eIgnore ==
nsContainerFrame::HandleEvent(aPresContext, aEvent)) {
nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus)) {
// If our child didn't take the click then since we are an
// anchor, we take the click.
nsIAtom* tag = mContent->GetTag();
@ -112,7 +113,7 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
mContent->GetAttribute("href", href);
mContent->GetAttribute("target", target);
TriggerLink(aPresContext, base, href, target);
rv = nsEventStatus_eConsumeNoDefault;
aEventStatus = nsEventStatus_eConsumeNoDefault;
}
NS_IF_RELEASE(tag);
}
@ -123,15 +124,16 @@ nsEventStatus nsHTMLContainerFrame::HandleEvent(nsIPresContext& aPresContext,
break;
default:
rv = nsContainerFrame::HandleEvent(aPresContext, aEvent);
nsContainerFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
break;
}
return rv;
return NS_OK;
}
PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame)
NS_METHOD nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor)
{
nsStyleMolecule* mol = (nsStyleMolecule*)
mStyleContext->GetData(kStyleMoleculeSID);
@ -139,9 +141,10 @@ PRInt32 nsHTMLContainerFrame::GetCursorAt(nsIPresContext& aPresContext,
// If this container has a particular cursor, use it, otherwise
// let the child decide.
*aFrame = this;
return (PRInt32) mol->cursor;
aCursor = (PRInt32)mol->cursor;
return NS_OK;
}
return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame);
return nsContainerFrame::GetCursorAt(aPresContext, aPoint, aFrame, aCursor);
}
#if 0

18
layout/html/base/src/nsHTMLContainerFrame.h
Просмотреть файл

@ -30,16 +30,18 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent);
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame);
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor);
#if 0
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,

55
layout/html/base/src/nsHTMLImage.cpp
Просмотреть файл

@ -44,16 +44,18 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParentFrame);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent);
NS_METHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame);
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor);
protected:
virtual ~ImageFrame();
@ -131,13 +133,13 @@ nsIImage* ImageFrame::GetImage(nsIPresContext& aPresContext)
return nsnull;
}
void ImageFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD ImageFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsIImage* image = GetImage(aPresContext);
if (nsnull == image) {
return;
return NS_OK;
}
// First paint background and borders
@ -156,6 +158,8 @@ void ImageFrame::Paint(nsIPresContext& aPresContext,
map->Draw(aPresContext, aRenderingContext);
}
}
return NS_OK;
}
nsIImageMap* ImageFrame::GetImageMap()
@ -201,10 +205,11 @@ void ImageFrame::TriggerLink(nsIPresContext& aPresContext,
}
// XXX what about transparent pixels?
nsEventStatus ImageFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent)
NS_METHOD ImageFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
nsEventStatus rv = nsEventStatus_eIgnore;
aEventStatus = nsEventStatus_eIgnore;
switch (aEvent->message) {
case NS_MOUSE_LEFT_BUTTON_UP:
@ -233,7 +238,7 @@ nsEventStatus ImageFrame::HandleEvent(nsIPresContext& aPresContext,
if (NS_OK == r) {
// We hit a clickable area. Time to go somewhere...
TriggerLink(aPresContext, absURL, target);
rv = nsEventStatus_eConsumeNoDefault;
aEventStatus = nsEventStatus_eConsumeNoDefault;
}
break;
}
@ -242,15 +247,16 @@ nsEventStatus ImageFrame::HandleEvent(nsIPresContext& aPresContext,
default:
// Let default event handler deal with it
return nsLeafFrame::HandleEvent(aPresContext, aEvent);
return nsLeafFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
}
return rv;
return NS_OK;
}
PRInt32 ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame)
NS_METHOD ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor)
{
nsStyleMolecule* mol = (nsStyleMolecule*)
mStyleContext->GetData(kStyleMoleculeSID);
@ -258,7 +264,7 @@ PRInt32 ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
// If this container has a particular cursor, use it, otherwise
// let the child decide.
*aFrame = this;
return (PRInt32) mol->cursor;
aCursor = (PRInt32) mol->cursor;
}
nsIImageMap* map = GetImageMap();
if (nsnull != map) {
@ -270,9 +276,10 @@ PRInt32 ImageFrame::GetCursorAt(nsIPresContext& aPresContext,
rv = NS_STYLE_CURSOR_HAND;
}
NS_RELEASE(map);
return rv;
return NS_OK;
}
return NS_STYLE_CURSOR_INHERIT;
aCursor = NS_STYLE_CURSOR_INHERIT;
return NS_OK;
}
void ImageFrame::GetDesiredSize(nsIPresContext* aPresContext,

158
layout/html/base/src/nsInlineFrame.cpp
Просмотреть файл

@ -241,17 +241,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No, the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -264,7 +269,9 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -274,16 +281,22 @@ PRBool nsInlineFrame::ReflowMappedChildren(nsIPresContext* aPresContext,
}
// Get the next child frame
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
// XXX talk with troy about checking for available space here
}
// Update the child count member data
mChildCount = childCount;
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
#ifdef NS_DEBUG
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
VerifyLastIsComplete();
#endif
return result;
@ -309,7 +322,9 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -338,7 +353,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
nsIFrame* next;
nextInFlow->GetNextInFlow(next);
nextInFlow = (nsInlineFrame*)next;
continue;
}
}
@ -346,8 +364,12 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetWidth() > aState.availSize.width) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.width > aState.availSize.width) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -369,7 +391,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
PlaceChild(kidFrame, mChildCount, aState, kidSize, pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -378,7 +400,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* kidContentParent;
kidFrame->GetContentParent(kidContentParent);
if (nextInFlow == kidContentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -398,13 +423,16 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -432,7 +460,7 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -452,7 +480,10 @@ PRBool nsInlineFrame::PullUpChildren(nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsInlineFrame*)nextInFlow->GetNextInFlow();
nsIFrame* next;
nextInFlow->GetNextInFlow(next);
nextInFlow = (nsInlineFrame*)next;
}
#endif
}
@ -492,7 +523,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
mFirstContentOffset = prev->NextChildOffset();
if (!prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
mLastContentIsComplete = PR_TRUE;
@ -501,8 +532,9 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsSize kidMaxElementSize;
nsSize* pKidMaxElementSize = (nsnull != aState.maxElementSize) ? &kidMaxElementSize : nsnull;
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -558,7 +590,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
}
kidFrame->SetStyleContext(kidStyleContext);
} else {
kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
}
NS_RELEASE(kid);
NS_RELEASE(kidStyleContext);
@ -606,7 +638,7 @@ nsInlineFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
done:;
// Update the content mapping
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
PRInt32 len = LengthOf(mFirstChild);
@ -618,11 +650,11 @@ done:;
return result;
}
nsIFrame::ReflowStatus
nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
@ -630,7 +662,8 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
//XXX not now NS_PRECONDITION((aMaxSize.width > 0) && (aMaxSize.height > 0), "unexpected max size");
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
aStatus = frComplete; // initialize out parameter
// Get the style molecule
nsStyleFont* styleFont =
@ -651,7 +684,7 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
reflowMappedOK = ReflowMappedChildren(aPresContext, state);
if (PR_FALSE == reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -661,18 +694,18 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
if (state.availSize.width <= 0) {
// No space left. Don't try to pull-up children or reflow unmapped
if (NextChildOffset() < mContent->ChildCount()) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (NextChildOffset() < mContent->ChildCount()) {
// Try and pull-up some children from a next-in-flow
if (PullUpChildren(aPresContext, state)) {
// If we still have unmapped children then create some new frames
if (NextChildOffset() < mContent->ChildCount()) {
status = ReflowUnmappedChildren(aPresContext, state);
aStatus = ReflowUnmappedChildren(aPresContext, state);
}
} else {
// We were unable to pull-up all the existing frames from the next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
@ -694,9 +727,9 @@ nsInlineFrame::ResizeReflow(nsIPresContext* aPresContext,
aDesiredSize.height = aDesiredSize.ascent + aDesiredSize.descent;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
return status;
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////////
@ -717,8 +750,8 @@ PRIntn nsInlineFrame::GetSkipSides() const
// Incremental reflow support
void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics)
NS_METHOD nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics)
{
nscoord maxAscent = 0;
nscoord maxDescent = 0;
@ -728,7 +761,7 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
kid->GetReflowMetrics(aPresContext, kidMetrics);
if (kidMetrics.ascent > maxAscent) maxAscent = kidMetrics.ascent;
if (kidMetrics.descent > maxDescent) maxDescent = kidMetrics.descent;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
// XXX what about border & padding
@ -736,6 +769,8 @@ void nsInlineFrame::GetReflowMetrics(nsIPresContext* aPresContext,
aMetrics.height = mRect.height;
aMetrics.ascent = maxAscent;
aMetrics.descent = maxDescent;
return NS_OK;
}
/**
@ -765,7 +800,7 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
// XXX Factor in left and right margins
x += kidMetrics.width;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
i++;
}
aState.maxAscent = maxAscent;
@ -774,13 +809,13 @@ PRIntn nsInlineFrame::RecoverState(nsIPresContext* aPresContext,
return (nsnull == aSkipChild) ? 0 : i;
}
nsIFrame::ReflowStatus
nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
ReflowStatus status = frComplete;
aStatus = frComplete; // initialize out parameter
#if 0
if (aReflowCommand.GetTarget() == this) {
@ -794,7 +829,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
while (nsnull != flow->mNextInFlow) {
flow = flow->mNextInFlow;
}
status = flow->ReflowUnmappedChildren(...);
aStatus = flow->ReflowUnmappedChildren(...);
break;
case nsReflowCommand::rcContentInserted:
@ -875,7 +910,7 @@ nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
// Now pass reflow command down to our child to handle
nsReflowMetrics kidMetrics;
status = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
aStatus = aReflowCommand.Next(kidMetrics, aMaxSize, kid);
// XXX what do we do when the nextInChain's completion status changes?
// XXX if kid == LastChild() then mLastContentIsComplete needs updating
@ -909,13 +944,13 @@ nsInlineFrame::IncrementalReflow(nsIPresContext* aPresContext,
// Update other children that are impacted by the change in
// nextInChain. In addition, re-apply vertical alignment and
// relative positioning to the children on the line.
status = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
kidMetrics, status);
aStatus = AdjustChildren(aPresContext, aDesiredSize, aState, kid,
kidMetrics, aStatus);
}
}
#endif
return status;
return NS_OK;
}
@ -961,7 +996,7 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
}
x += r.width;
// XXX factor in left and right margins
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
// Vertically align the children
@ -981,25 +1016,19 @@ nsInlineFrame::AdjustChildren(nsIPresContext* aPresContext,
// My container has new content at the end of it. Create frames for
// the appended content and then generate an incremental reflow
// command for ourselves.
void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
NS_METHOD nsInlineFrame::ContentAppended(nsIPresShell* aShell,
nsIPresContext* aPresContext,
nsIContent* aContainer)
{
// Zip down to the end-of-flow
nsInlineFrame* flow = this;
for (;;) {
nsInlineFrame* next = (nsInlineFrame*) flow->GetNextInFlow();
if (nsnull == next) {
break;
}
flow = next;
}
// Get the last in flow
nsInlineFrame* flow = (nsInlineFrame*)GetLastInFlow();
// Get index of where the content has been appended
PRInt32 kidIndex = flow->NextChildOffset();
PRInt32 startIndex = kidIndex;
nsIFrame* prevKidFrame = flow->LastChild();
nsIFrame* prevKidFrame;
flow->LastChild(prevKidFrame);
// Create frames for each new child
for (;;) {
// Get the next content object
@ -1027,4 +1056,5 @@ void nsInlineFrame::ContentAppended(nsIPresShell* aShell,
startIndex);
aShell->AppendReflowCommand(rc);
}
return NS_OK;
}

41
layout/html/base/src/nsLeafFrame.cpp
Просмотреть файл

@ -33,9 +33,9 @@ nsLeafFrame::~nsLeafFrame()
{
}
void nsLeafFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsLeafFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsStyleColor* myColor =
(nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@ -45,13 +45,14 @@ void nsLeafFrame::Paint(nsIPresContext& aPresContext,
aDirtyRect, mRect, *myColor);
nsCSSRendering::PaintBorder(aPresContext, aRenderingContext, this,
aDirtyRect, mRect, *myMol, 0);
return NS_OK;
}
nsIFrame::ReflowStatus
nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
// XXX add in code to check for width/height being set via css
// and if set use them instead of calling GetDesiredSize.
@ -62,14 +63,15 @@ nsLeafFrame::ResizeReflow(nsIPresContext* aPresContext,
aMaxElementSize->width = aDesiredSize.width;
aMaxElementSize->height = aDesiredSize.height;
}
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
// XXX Unless the reflow command is a style change, we should
// just return the current size, otherwise we should invoke
@ -80,7 +82,8 @@ nsLeafFrame::IncrementalReflow(nsIPresContext* aPresContext,
GetDesiredSize(aPresContext, aDesiredSize, aMaxSize);
AddBordersAndPadding(aPresContext, aDesiredSize);
return frComplete;
aStatus = frComplete;
return NS_OK;
}
// XXX how should border&padding effect baseline alignment?
@ -109,9 +112,11 @@ void nsLeafFrame::GetInnerArea(nsIPresContext* aPresContext,
(mol->borderPadding.top + mol->borderPadding.bottom);
}
nsIFrame* nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsLeafFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
NS_NOTREACHED("Attempt to split the unsplittable");
return nsnull;
aContinuingFrame = nsnull;
return NS_OK;
}

29
layout/html/base/src/nsLeafFrame.h
Просмотреть файл

@ -28,22 +28,25 @@
*/
class nsLeafFrame : public nsFrame {
public:
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
protected:
nsLeafFrame(nsIContent* aContent,

115
layout/html/base/src/nsListItemFrame.cpp
Просмотреть файл

@ -54,19 +54,21 @@ public:
nsIFrame* aParentFrame);
virtual ~BulletFrame();
virtual void Paint(nsIPresContext &aCX,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext &aCX,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual ReflowStatus ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
void GetBulletSize(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
@ -95,9 +97,9 @@ BulletFrame::~BulletFrame()
// XXX padding for around the bullet; should come from style system
#define PAD_DISC NS_POINTS_TO_TWIPS_INT(1)
void BulletFrame::Paint(nsIPresContext& aCX,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD BulletFrame::Paint(nsIPresContext& aCX,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsStyleFont* myFont =
(nsStyleFont*)mStyleContext->GetData(kStyleFontSID);
@ -135,13 +137,14 @@ void BulletFrame::Paint(nsIPresContext& aCX,
break;
}
NS_RELEASE(fm);
return NS_OK;
}
nsIFrame::ReflowStatus
BulletFrame::ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD BulletFrame::ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
GetBulletSize(aCX, aDesiredSize, aMaxSize);
if (nsnull != aMaxElementSize) {
@ -154,22 +157,23 @@ BulletFrame::ResizeReflow(nsIPresContext* aCX,
// the bullet must be mapping the second content object instead of
// mapping the first content object.
mLastContentIsComplete = PR_FALSE;
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
BulletFrame::IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD BulletFrame::IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
// XXX Unless the reflow command is a style change, we should
// just return the current size, otherwise we should invoke
// GetBulletSize
GetBulletSize(aCX, aDesiredSize, aMaxSize);
return frComplete;
aStatus = frComplete;
return NS_OK;
}
PRInt32 BulletFrame::GetListItemOrdinal(nsIPresContext* aCX,
@ -522,7 +526,9 @@ nsListItemFrame::GetListContainerReflowState(nsIPresContext* aCX)
// The parent is a block. See if its content object is a list
// container. Only UL, OL, MENU or DIR can be list containers.
// XXX need something more flexible, say style?
nsIContent* parentContent = parent->GetContent();
nsIContent* parentContent;
parent->GetContent(parentContent);
nsIAtom* tag = parentContent->GetTag();
NS_RELEASE(parentContent);
if ((tag == nsHTMLAtoms::ul) || (tag == nsHTMLAtoms::ol) ||
@ -533,7 +539,7 @@ nsListItemFrame::GetListContainerReflowState(nsIPresContext* aCX)
NS_RELEASE(tag);
}
}
parent = parent->GetGeometricParent();
parent->GetGeometricParent(parent);
}
if (nsnull != parent) {
nsIPresShell* shell = aCX->GetShell();
@ -550,12 +556,12 @@ nsListItemFrame::GetListContainerReflowState(nsIPresContext* aCX)
*/
// XXX we may need to grow to accomodate the bullet
// XXX check for compatability: <LI><H1>dah dah</H1> where is bullet?
nsIFrame::ReflowStatus
nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize)
NS_METHOD nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
PRBool insideBullet = PR_FALSE;
@ -586,7 +592,7 @@ nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
} else {
// Pull bullet off list (we'll put it back later)
bullet = mFirstChild;
mFirstChild = bullet->GetNextSibling();
bullet->GetNextSibling(mFirstChild);
mChildCount--;
}
}
@ -596,7 +602,7 @@ nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
nsBlockReflowState state;
SetupState(aCX, state, aMaxSize, aMaxElementSize, aSpaceManager);
state.firstChildIsInsideBullet = insideBullet;
ReflowStatus rv = DoResizeReflow(aCX, state, aDesiredRect);
DoResizeReflow(aCX, state, aDesiredRect, aStatus);
// Now place the bullet and put it at the head of the list of children
if (!insideBullet && (nsnull != bullet)) {
@ -616,26 +622,29 @@ nsListItemFrame::ResizeReflow(nsIPresContext* aCX,
mLines[0]++;
}
}
return rv;
return NS_OK;
}
// XXX we may need to grow to accomodate the bullet
nsIFrame::ReflowStatus
nsListItemFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand)
NS_METHOD nsListItemFrame::IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame* nsListItemFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent)
NS_METHOD nsListItemFrame::CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsListItemFrame* cf = new nsListItemFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aCX, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
// aDirtyRect is in our coordinate system
@ -646,7 +655,9 @@ void nsListItemFrame::PaintChildren(nsIPresContext& aCX,
{
nsIFrame* kid = mFirstChild;
while (nsnull != kid) {
nsIView *pView = kid->GetView();
nsIView *pView;
kid->GetView(pView);
if (nsnull == pView) {
nsRect kidRect;
kid->GetRect(kidRect);
@ -668,9 +679,9 @@ void nsListItemFrame::PaintChildren(nsIPresContext& aCX,
}
aRenderingContext.PopState();
}
}
else
} else {
NS_RELEASE(pView);
kid = kid->GetNextSibling();
}
kid->GetNextSibling(kid);
}
}

27
layout/html/base/src/nsListItemFrame.h
Просмотреть файл

@ -28,20 +28,23 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual ReflowStatus ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aCX,
nsISpaceManager* aSpaceManager,
const nsSize& aMaxSize,
nsRect& aDesiredRect,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aCX,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
/**
* Return the reflow state for the list container that contains this

73
layout/html/base/src/nsPageFrame.cpp
Просмотреть файл

@ -23,8 +23,8 @@
#include "nsReflowCommand.h"
#include "nsIRenderingContext.h"
PageFrame::PageFrame(nsIContent* aContent, nsIFrame* aParent)
: nsContainerFrame(aContent, aParent->GetIndexInParent(), aParent)
PageFrame::PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent)
: nsContainerFrame(aContent, aIndexInParent, aParent)
{
}
@ -56,16 +56,16 @@ void PageFrame::CreateFirstChild(nsIPresContext* aPresContext)
}
}
nsIFrame::ReflowStatus
PageFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD PageFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
#endif
ReflowStatus result = frComplete;
aStatus = frComplete; // initialize out parameter
// Do we have any children?
if (nsnull == mFirstChild) {
@ -76,10 +76,11 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
PageFrame* prevPage = (PageFrame*)mPrevInFlow;
NS_ASSERTION(!prevPage->mLastContentIsComplete, "bad continuing page");
nsIFrame* prevLastChild = prevPage->LastChild();
nsIFrame* prevLastChild;
prevPage->LastChild(prevLastChild);
// Create a continuing child of the previous page's last child
mFirstChild = prevLastChild->CreateContinuingFrame(aPresContext, this);
prevLastChild->CreateContinuingFrame(aPresContext, this, mFirstChild);
mChildCount = 1;
mLastContentOffset = mFirstContentOffset;
}
@ -89,9 +90,9 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
// XXX Pay attention to the page's border and padding...
if (nsnull != mFirstChild) {
// Get the child's desired size
result = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
aMaxElementSize);
mLastContentIsComplete = PRBool(result == frComplete);
aStatus = ReflowChild(mFirstChild, aPresContext, aDesiredSize, aMaxSize,
aMaxElementSize);
mLastContentIsComplete = PRBool(aStatus == frComplete);
// Make sure the child is at least as tall as our max size (the containing window)
if (aDesiredSize.height < aMaxSize.height) {
@ -103,8 +104,11 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
mFirstChild->SetRect(rect);
// Is the frame complete?
if (frComplete == result) {
NS_ASSERTION(nsnull == mFirstChild->GetNextInFlow(), "bad child flow list");
if (frComplete == aStatus) {
nsIFrame* childNextInFlow;
mFirstChild->GetNextInFlow(childNextInFlow);
NS_ASSERTION(nsnull == childNextInFlow, "bad child flow list");
}
}
@ -113,28 +117,27 @@ PageFrame::ResizeReflow(nsIPresContext* aPresContext,
aDesiredSize.height = aMaxSize.height;
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
return result;
return NS_OK;
}
// XXX Do something sensible in page mode...
nsIFrame::ReflowStatus
PageFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD PageFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
// We don't expect the target of the reflow command to be page frame
NS_ASSERTION(aReflowCommand.GetTarget() != this, "page frame is reflow command target");
nsSize maxSize(aMaxSize.width, NS_UNCONSTRAINEDSIZE);
ReflowStatus status;
nsIFrame* child;
// Dispatch the reflow command to our pseudo frame. Allow it to be as high
// as it wants
status = aReflowCommand.Next(aDesiredSize, maxSize, child);
aStatus = aReflowCommand.Next(aDesiredSize, maxSize, child);
// Place and size the child. Make sure the child is at least as
// tall as our max size (the containing window)
@ -148,20 +151,22 @@ PageFrame::IncrementalReflow(nsIPresContext* aPresContext,
child->SetRect(rect);
}
return status;
return NS_OK;
}
nsIFrame* PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD PageFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
PageFrame* cf = new PageFrame(mContent, aParent);
PageFrame* cf = new PageFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
void PageFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD PageFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect);
@ -169,10 +174,12 @@ void PageFrame::Paint(nsIPresContext& aPresContext,
// where each page begins and ends
aRenderingContext.SetColor(NS_RGB(0, 0, 0));
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
return NS_OK;
}
void PageFrame::ListTag(FILE* out) const
NS_METHOD PageFrame::ListTag(FILE* out) const
{
fprintf(out, "*PAGE@%p", this);
return NS_OK;
}

33
layout/html/base/src/nsPageFrame.h
Просмотреть файл

@ -23,27 +23,30 @@
// Pseudo frame created by the root content frame
class PageFrame : public nsContainerFrame {
public:
PageFrame(nsIContent* aContent, nsIFrame* aParent);
PageFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
// Debugging
virtual void ListTag(FILE* out = stdout) const;
NS_IMETHOD ListTag(FILE* out = stdout) const;
protected:
void CreateFirstChild(nsIPresContext* aPresContext);

19
layout/html/base/src/nsPlaceholderFrame.cpp
Просмотреть файл

@ -52,16 +52,16 @@ PlaceholderFrame::~PlaceholderFrame()
{
}
nsIFrame::ReflowStatus
PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
// Get the floater container in which we're inserted
nsIFloaterContainer* container = nsnull;
for (nsIFrame* parent = mGeometricParent; parent; parent = parent->GetGeometricParent()) {
for (nsIFrame* parent = mGeometricParent; parent; parent->GetGeometricParent(parent)) {
if (NS_OK == parent->QueryInterface(kIFloaterContainerIID, (void**)&container)) {
break;
}
@ -82,7 +82,7 @@ PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
// Resize reflow the anchored item into the available space
// XXX Check for complete?
mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
mAnchoredItem->ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
mAnchoredItem->SizeTo(aDesiredSize.width, aDesiredSize.height);
// Now notify our containing block that there's a new floater
@ -91,11 +91,12 @@ PlaceholderFrame::ResizeReflow(nsIPresContext* aPresContext,
container->PlaceFloater(aPresContext, mAnchoredItem, this);
}
return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize);
return nsFrame::ResizeReflow(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, aStatus);
}
void PlaceholderFrame::ListTag(FILE* out) const
NS_METHOD PlaceholderFrame::ListTag(FILE* out) const
{
fputs("*placeholder", out);
fprintf(out, "(%d)@%p", mIndexInParent, this);
return NS_OK;
}

11
layout/html/base/src/nsPlaceholderFrame.h
Просмотреть файл

@ -36,11 +36,12 @@ public:
nsIFrame* GetAnchoredItem() const {return mAnchoredItem;}
// Resize reflow methods
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
virtual void ListTag(FILE* out = stdout) const;
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
NS_IMETHOD ListTag(FILE* out = stdout) const;
protected:
// Constructor. Takes as arguments the content object, the index in parent,

182
layout/html/base/src/nsRootPart.cpp
Просмотреть файл

@ -39,38 +39,43 @@ class RootFrame : public nsContainerFrame {
public:
RootFrame(nsIContent* aContent);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent);
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
};
// Pseudo frame created by the root frame
class RootContentFrame : public nsContainerFrame {
public:
RootContentFrame(nsIContent* aContent, nsIFrame* aParent);
RootContentFrame(nsIContent* aContent, PRInt32 aIndexInParent, nsIFrame* aParent);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
protected:
void CreateFirstChild(nsIPresContext* aPresContext);
@ -83,20 +88,21 @@ RootFrame::RootFrame(nsIContent* aContent)
{
}
nsIFrame::ReflowStatus RootFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD RootFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
#endif
nsIFrame::ReflowStatus result = frComplete;
aStatus = frComplete;
// Do we have any children?
if (nsnull == mFirstChild) {
// No. Create a pseudo frame
mFirstChild = new RootContentFrame(mContent, this);
mFirstChild = new RootContentFrame(mContent, mIndexInParent, this);
mChildCount = 1;
nsIStyleContext* style = aPresContext->ResolveStyleContextFor(mContent, this);
mFirstChild->SetStyleContext(style);
@ -107,7 +113,8 @@ nsIFrame::ReflowStatus RootFrame::ResizeReflow(nsIPresContext* aPresContext,
// height its child frame wants...
if (nsnull != mFirstChild) {
nsReflowMetrics desiredSize;
result = ReflowChild(mFirstChild, aPresContext, desiredSize, aMaxSize,
aStatus = ReflowChild(mFirstChild, aPresContext, desiredSize, aMaxSize,
aMaxElementSize);
// Place and size the child
@ -123,26 +130,25 @@ nsIFrame::ReflowStatus RootFrame::ResizeReflow(nsIPresContext* aPresContext,
aDesiredSize.descent = 0;
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
return result;
return NS_OK;
}
nsIFrame::ReflowStatus
RootFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD RootFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
// We don't expect the target of the reflow command to be the root frame
NS_ASSERTION(aReflowCommand.GetTarget() != this, "root frame is reflow command target");
nsReflowMetrics desiredSize;
nsIFrame* child;
ReflowStatus status;
// Dispatch the reflow command to our pseudo frame
status = aReflowCommand.Next(desiredSize, aMaxSize, child);
aStatus = aReflowCommand.Next(desiredSize, aMaxSize, child);
// Place and size the child
if (nsnull != child) {
@ -157,18 +163,21 @@ RootFrame::IncrementalReflow(nsIPresContext* aPresContext,
aDesiredSize.height = aMaxSize.height;
aDesiredSize.ascent = aMaxSize.height;
aDesiredSize.descent = 0;
return status;
return NS_OK;
}
nsEventStatus RootFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent)
NS_METHOD RootFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
switch (aEvent->message) {
case NS_MOUSE_MOVE:
case NS_MOUSE_ENTER:
{
nsIFrame* target = this;
PRInt32 cursor = GetCursorAt(aPresContext, aEvent->point, &target);
PRInt32 cursor;
GetCursorAt(aPresContext, aEvent->point, &target, cursor);
if (cursor == NS_STYLE_CURSOR_INHERIT) {
cursor = NS_STYLE_CURSOR_DEFAULT;
}
@ -185,26 +194,33 @@ nsEventStatus RootFrame::HandleEvent(nsIPresContext& aPresContext,
c = eCursor_select;
break;
}
nsIWidget* window = target->GetWindow();
nsIWidget* window;
target->GetWindow(window);
window->SetCursor(c);
}
break;
}
return nsEventStatus_eIgnore;
aEventStatus = nsEventStatus_eIgnore;
return NS_OK;
}
//----------------------------------------------------------------------
RootContentFrame::RootContentFrame(nsIContent* aContent, nsIFrame* aParent)
: nsContainerFrame(aContent, aParent->GetIndexInParent(), aParent)
RootContentFrame::RootContentFrame(nsIContent* aContent,
PRInt32 aIndexInParent,
nsIFrame* aParent)
: nsContainerFrame(aContent, aIndexInParent, aParent)
{
// Create a view
nsIFrame* parent = GetParentWithView();
nsIFrame* parent;
nsIView* view;
GetParentWithView(parent);
NS_ASSERTION(parent, "GetParentWithView failed");
nsIView* parView = parent->GetView();
nsIView* parView;
parent->GetView(parView);
NS_ASSERTION(parView, "no parent with view");
// Create a view
@ -222,7 +238,7 @@ RootContentFrame::RootContentFrame(nsIContent* aContent, nsIFrame* aParent)
// Initialize the view
NS_ASSERTION(nsnull != viewManager, "null view manager");
view->Init(viewManager, GetRect(), rootView);
view->Init(viewManager, mRect, rootView);
viewManager->InsertChild(rootView, view, 0);
NS_RELEASE(viewManager);
@ -239,7 +255,7 @@ void RootContentFrame::CreateFirstChild(nsIPresContext* aPresContext)
// Are we paginated?
if (aPresContext->IsPaginated()) {
// Yes. Create the first page frame
mFirstChild = new PageFrame(mContent, this);
mFirstChild = new PageFrame(mContent, mIndexInParent, this);
mChildCount = 1;
mLastContentOffset = mFirstContentOffset;
@ -274,16 +290,16 @@ void RootContentFrame::CreateFirstChild(nsIPresContext* aPresContext)
// XXX Hack
#define PAGE_SPACING 100
nsIFrame::ReflowStatus
RootContentFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD RootContentFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NS_DEBUG
PreReflowCheck();
#endif
nsIFrame::ReflowStatus result = frComplete;
aStatus = frComplete;
// Do we have any children?
if (nsnull == mFirstChild) {
@ -317,23 +333,31 @@ RootContentFrame::ResizeReflow(nsIPresContext* aPresContext,
y += PAGE_SPACING;
// Is the page complete?
nsIFrame* nextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (frComplete == status) {
NS_ASSERTION(nsnull == kidFrame->GetNextInFlow(), "bad child flow list");
} else if (nsnull == nextInFlow) {
NS_ASSERTION(nsnull == kidNextInFlow, "bad child flow list");
} else if (nsnull == kidNextInFlow) {
// The page isn't complete and it doesn't have a next-in-flow so
// create a continuing page
nsIFrame* continuingPage = kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingPage;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingPage);
// Add it to our child list
NS_ASSERTION(nsnull == kidFrame->GetNextSibling(), "unexpected sibling");
#ifdef NS_DEBUG
nsIFrame* kidNextSibling;
kidFrame->GetNextSibling(kidNextSibling);
NS_ASSERTION(nsnull == kidNextSibling, "unexpected sibling");
#endif
kidFrame->SetNextSibling(continuingPage);
mChildCount++;
}
// Get the next page
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
// Return our desired size
@ -347,9 +371,9 @@ RootContentFrame::ResizeReflow(nsIPresContext* aPresContext,
// Get the child's desired size. Our child's desired height is our
// desired size
result = ReflowChild(mFirstChild, aPresContext, aDesiredSize, maxSize,
aMaxElementSize);
NS_ASSERTION(frComplete == result, "bad status");
aStatus = ReflowChild(mFirstChild, aPresContext, aDesiredSize, maxSize,
aMaxElementSize);
NS_ASSERTION(frComplete == aStatus, "bad status");
// Place and size the child. Make sure the child is at least as
// tall as our max size (the containing window)
@ -364,29 +388,28 @@ RootContentFrame::ResizeReflow(nsIPresContext* aPresContext,
}
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
return result;
return NS_OK;
}
// XXX Do something sensible for page mode...
nsIFrame::ReflowStatus
RootContentFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD RootContentFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
// We don't expect the target of the reflow command to be the root
// content frame
NS_ASSERTION(aReflowCommand.GetTarget() != this, "root content frame is reflow command target");
nsSize maxSize(aMaxSize.width, NS_UNCONSTRAINEDSIZE);
ReflowStatus status;
nsIFrame* child;
// Dispatch the reflow command to our pseudo frame. Allow it to be as high
// as it wants
status = aReflowCommand.Next(aDesiredSize, maxSize, child);
aStatus = aReflowCommand.Next(aDesiredSize, maxSize, child);
// Place and size the child. Make sure the child is at least as
// tall as our max size (the containing window)
@ -400,12 +423,12 @@ RootContentFrame::IncrementalReflow(nsIPresContext* aPresContext,
child->SetRect(rect);
}
return status;
return NS_OK;
}
void RootContentFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD RootContentFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// If we're paginated then fill the dirty rect with white
if (aPresContext.IsPaginated()) {
@ -415,6 +438,7 @@ void RootContentFrame::Paint(nsIPresContext& aPresContext,
}
nsContainerFrame::Paint(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
//----------------------------------------------------------------------

2
layout/html/base/src/nsSpacerPart.cpp
Просмотреть файл

@ -100,7 +100,7 @@ SpacerFrame::ResizeReflow(nsIPresContext* aPresContext,
break;
}
}
parent = parent->GetGeometricParent();
parent->GetGeometricParent(parent);
}
if (nsnull != parent) {
nsIPresShell* shell = aPresContext->GetShell();

91
layout/html/base/src/nsTextContent.cpp
Просмотреть файл

@ -110,26 +110,28 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParentFrame);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual ReflowStatus ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual void GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
NS_IMETHOD GetReflowMetrics(nsIPresContext* aPresContext,
nsReflowMetrics& aMetrics);
virtual void JustifyReflow(nsIPresContext* aCX,
nscoord aAvailableSpace);
NS_IMETHOD JustifyReflow(nsIPresContext* aCX,
nscoord aAvailableSpace);
virtual PRInt32 GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame);
NS_IMETHOD GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor);
virtual void List(FILE* out, PRInt32 aIndent) const;
NS_IMETHOD List(FILE* out, PRInt32 aIndent) const;
protected:
virtual ~TextFrame();
@ -340,7 +342,8 @@ void TextTimer::Notify(nsITimer *timer)
nsPoint offset;
nsRect bounds;
text->GetRect(bounds);
nsIView* view = text->GetOffsetFromView(offset);
nsIView* view;
text->GetOffsetFromView(offset, view);
nsIViewManager* vm = view->GetViewManager();
bounds.x = offset.x;
bounds.y = offset.y;
@ -379,9 +382,10 @@ TextFrame::~TextFrame()
}
}
PRInt32 TextFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame)
NS_METHOD TextFrame::GetCursorAt(nsIPresContext& aPresContext,
const nsPoint& aPoint,
nsIFrame** aFrame,
PRInt32& aCursor)
{
nsStyleMolecule* mol = (nsStyleMolecule*)
mStyleContext->GetData(kStyleMoleculeSID);
@ -390,18 +394,19 @@ PRInt32 TextFrame::GetCursorAt(nsIPresContext& aPresContext,
// let the child decide.
*aFrame = this;
}
return (PRInt32) mol->cursor;
aCursor = (PRInt32) mol->cursor;
return NS_OK;
}
// XXX it would be nice to use a method pointer here, but I don't want
// to pay for the storage.
void TextFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD TextFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
if ((0 != (mFlags & TEXT_BLINK_ON)) && gBlinkTextOff) {
return;
return NS_OK;
}
// Get style data
@ -421,7 +426,7 @@ void TextFrame::Paint(nsIPresContext& aPresContext,
aRenderingContext.SetColor(color->mBackgroundColor);
PaintJustifiedText(aRenderingContext, aDirtyRect, onePixel, onePixel);
}
return;
return NS_OK;
}
PaintRegularText(aRenderingContext, aDirtyRect, 0, 0);
if (font->mThreeD) {
@ -429,6 +434,8 @@ void TextFrame::Paint(nsIPresContext& aPresContext,
aRenderingContext.SetColor(color->mBackgroundColor);
PaintRegularText(aRenderingContext, aDirtyRect, onePixel, onePixel);
}
return NS_OK;
}
void TextFrame::PaintRegularText(nsIRenderingContext& aRenderingContext,
@ -619,8 +626,8 @@ void TextFrame::PaintJustifiedText(nsIRenderingContext& aRenderingContext,
}
}
void TextFrame::GetReflowMetrics(nsIPresContext* aCX,
nsReflowMetrics& aMetrics)
NS_METHOD TextFrame::GetReflowMetrics(nsIPresContext* aCX,
nsReflowMetrics& aMetrics)
{
aMetrics.width = mRect.width;
aMetrics.height = mRect.height;
@ -631,13 +638,14 @@ void TextFrame::GetReflowMetrics(nsIPresContext* aCX,
aMetrics.ascent = fm->GetMaxAscent();
aMetrics.descent = fm->GetMaxDescent();
NS_RELEASE(fm);
return NS_OK;
}
nsIFrame::ReflowStatus
TextFrame::ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD TextFrame::ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
#ifdef NOISY
ListTag(stdout);
@ -674,7 +682,7 @@ TextFrame::ResizeReflow(nsIPresContext* aCX,
break;
}
}
parent = parent->GetGeometricParent();
parent->GetGeometricParent(parent);
}
if (nsnull != parent) {
nsIPresShell* shell = aCX->GetShell();
@ -698,24 +706,23 @@ TextFrame::ResizeReflow(nsIPresContext* aCX,
nsStyleMolecule* mol =
(nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
ReflowStatus status;
if (NS_STYLE_WHITESPACE_PRE == mol->whiteSpace) {
// Use a specialized routine for pre-formatted text
status = ReflowPre(aCX, aDesiredSize, aMaxSize,
aStatus = ReflowPre(aCX, aDesiredSize, aMaxSize,
aMaxElementSize, *font, startingOffset, state);
} else {
// Use normal wrapping routine for non-pre text (this includes
// text that is not wrapping)
status = ReflowNormal(aCX, aDesiredSize, aMaxSize,
aStatus = ReflowNormal(aCX, aDesiredSize, aMaxSize,
aMaxElementSize, *font, *mol, startingOffset, state);
}
#ifdef NOISY
ListTag(stdout);
printf(": reflow %scomplete [flags=%x]\n",
((status == frComplete) ? "" : "not "), mFlags);
((aStatus == frComplete) ? "" : "not "), mFlags);
#endif
return status;
return NS_OK;
}
// Reflow normal text (stuff that doesn't have to deal with horizontal
@ -960,11 +967,11 @@ TextFrame::ReflowPre(nsIPresContext* aCX,
#define NUM_WORDS 20
void TextFrame::JustifyReflow(nsIPresContext* aCX, nscoord aAvailableSpace)
NS_METHOD TextFrame::JustifyReflow(nsIPresContext* aCX, nscoord aAvailableSpace)
{
if (mFlags & TEXT_IS_PRE) {
// no way
return;
return NS_OK;
}
nsStyleFont* font =
@ -1145,10 +1152,11 @@ bail:
delete wp0;
}
NS_RELEASE(fm);
return NS_OK;
}
#undef NUM_WORDS
void TextFrame::List(FILE* out, PRInt32 aIndent) const
NS_METHOD TextFrame::List(FILE* out, PRInt32 aIndent) const
{
PRInt32 i;
for (i = aIndent; --i >= 0; ) fputs(" ", out);
@ -1189,6 +1197,7 @@ void TextFrame::List(FILE* out, PRInt32 aIndent) const
fputs("\n", out);
}
#endif
return NS_OK;
}
//----------------------------------------------------------------------

10
layout/html/forms/src/nsInputButton.cpp
Просмотреть файл

@ -274,7 +274,7 @@ nsInputButtonFrame::~nsInputButtonFrame()
void
nsInputButtonFrame::MouseClicked()
{
nsInputButton* button = (nsInputButton *) GetContent();
nsInputButton* button = (nsInputButton *)mContent;
nsIFormManager* formMan = button->GetFormManager();
if (nsnull != formMan) {
if (kInputButtonReset == button->GetButtonType()) {
@ -284,7 +284,6 @@ nsInputButtonFrame::MouseClicked()
}
NS_RELEASE(formMan);
}
NS_RELEASE(button);
}
@ -293,10 +292,9 @@ nsInputButtonFrame::PreInitializeWidget(nsIPresContext* aPresContext, nsSize& aB
{
float p2t = aPresContext->GetPixelsToTwips();
nsInputButton* content = (nsInputButton *)GetContent(); // this must be an nsInputButton
nsIStyleContext* styleContext = GetStyleContext(aPresContext);
nsInputButton* content = (nsInputButton *)mContent; // this must be an nsInputButton
// should this be the parent
nsStyleFont* styleFont = (nsStyleFont*)styleContext->GetData(kStyleFontSID);
nsStyleFont* styleFont = (nsStyleFont*)mStyleContext->GetData(kStyleFontSID);
nsIDeviceContext* deviceContext = aPresContext->GetDeviceContext();
nsIFontCache* fontCache = deviceContext->GetFontCache();
@ -321,8 +319,6 @@ nsInputButtonFrame::PreInitializeWidget(nsIPresContext* aPresContext, nsSize& aB
NS_RELEASE(fontMet);
NS_RELEASE(fontCache);
NS_RELEASE(deviceContext);
NS_RELEASE(styleContext);
NS_RELEASE(content);
}

6
layout/html/forms/src/nsInputCheckbox.cpp
Просмотреть файл

@ -84,7 +84,7 @@ void
nsInputCheckboxFrame::PreInitializeWidget(nsIPresContext* aPresContext,
nsSize& aBounds)
{
nsInputCheckbox* content = (nsInputCheckbox *)GetContent(); // this must be an nsCheckbox
nsInputCheckbox* content = (nsInputCheckbox *)mContent; // this must be an nsCheckbox
// get the state
nsHTMLValue value;
@ -92,7 +92,6 @@ nsInputCheckboxFrame::PreInitializeWidget(nsIPresContext* aPresContext,
if (result != eContentAttr_NotThere) {
mCacheState = PR_TRUE;/* XXX why cache state? */
}
NS_RELEASE(content);
float p2t = aPresContext->GetPixelsToTwips();
aBounds.width = (int)(13 * p2t);
@ -113,7 +112,8 @@ void
nsInputCheckboxFrame::MouseClicked()
{
nsICheckButton* checkbox;
nsIView* view = GetView();
nsIView* view;
GetView(view);
if (NS_OK == GetWidget(view, (nsIWidget **)&checkbox)) {
PRBool newState = (checkbox->GetState()) ? PR_FALSE : PR_TRUE;
checkbox->SetState(newState);

50
layout/html/forms/src/nsInputFrame.cpp
Просмотреть файл

@ -56,7 +56,7 @@ nsInputFrame::~nsInputFrame()
// XXX it would be cool if form element used our rendering sw, then
// they could be blended, and bordered, and so on...
void
NS_METHOD
nsInputFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
@ -64,11 +64,13 @@ nsInputFrame::Paint(nsIPresContext& aPresContext,
static NS_DEFINE_IID(kIWidgetIID, NS_IWIDGET_IID);
nsPoint offset;
nsIView *parent = GetOffsetFromView(offset);
nsIView *parent;
GetOffsetFromView(offset, parent);
if (nsnull == parent) { // a problem
NS_ASSERTION(0, "parent view was null\n");
} else {
nsIView* view = GetView();
nsIView* view;
GetView(view);
float t2p = aPresContext.GetTwipsToPixels();
//nsIWidget *widget = view->GetWindow();
nsIWidget* widget;
@ -90,6 +92,7 @@ nsInputFrame::Paint(nsIPresContext& aPresContext,
NS_RELEASE(view);
NS_RELEASE(parent);
}
return NS_OK;
}
PRBool
@ -125,16 +128,18 @@ nsInputFrame::PreInitializeWidget(nsIPresContext* aPresContext,
aBounds.height = (int)(10 * p2t);
}
nsIFrame::ReflowStatus
NS_METHOD
nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
// XXX add in code to check for width/height being set via css
// and if set use them instead of calling GetDesiredSize.
nsIView* view = GetView();
nsIView* view;
GetView(view);
if (nsnull == view) {
static NS_DEFINE_IID(kViewCID, NS_VIEW_CID);
@ -144,7 +149,8 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
NSRepository::CreateInstance(kViewCID, nsnull, kIViewIID, (void **)&view);// need to release
if (NS_OK != result) {
NS_ASSERTION(0, "Could not create view for button");
return frNotComplete;
aStatus = frNotComplete;
return NS_OK;
}
nsIPresShell *presShell = aPresContext->GetShell(); // need to release
nsIViewManager *viewMan = presShell->GetViewManager(); // need to release
@ -153,7 +159,11 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
//float t2p = aPresContext->GetTwipsToPixels();
nsRect boundBox(0, 0, mCacheBounds.width, mCacheBounds.height);
nsIView *parView = GetParentWithView()->GetView();
nsIFrame* parWithView;
nsIView *parView;
GetParentWithView(parWithView);
parWithView->GetView(parView);
const nsIID id = GetCID();
// initialize the view as hidden since we don't know the (x,y) until Paint
@ -161,17 +171,17 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
1.0f, nsViewVisibility_kHide);
if (NS_OK != result) {
NS_ASSERTION(0, "widget initialization failed");
return frNotComplete;
aStatus = frNotComplete;
return NS_OK;
}
// set the content's widget, so it can get content modified by the widget
nsIWidget *widget;
result = GetWidget(view, &widget);
if (NS_OK == result) {
nsInput* content = (nsInput *)GetContent(); // change this cast to QueryInterface
nsInput* content = (nsInput *)mContent; // change this cast to QueryInterface
content->SetWidget(widget);
NS_IF_RELEASE(widget);
NS_RELEASE(content);
} else {
NS_ASSERTION(0, "could not get widget");
}
@ -195,8 +205,8 @@ nsInputFrame::ResizeReflow(nsIPresContext* aPresContext,
aMaxElementSize->height = aDesiredSize.height;
}
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsresult
@ -225,13 +235,15 @@ nsInputFrame::GetCID()
return kButtonCID;
}
nsEventStatus nsInputFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent)
NS_METHOD nsInputFrame::HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus)
{
// make sure that the widget in the event is this
static NS_DEFINE_IID(kSupportsIID, NS_ISUPPORTS_IID);
nsIWidget* thisWidget;
nsIView* view = GetView();
nsIView* view;
GetView(view);
nsresult result = GetWidget(view, &thisWidget);
nsISupports* thisWidgetSup;
result = thisWidget->QueryInterface(kSupportsIID, (void **)&thisWidgetSup);
@ -246,7 +258,8 @@ nsEventStatus nsInputFrame::HandleEvent(nsIPresContext& aPresContext,
NS_IF_RELEASE(thisWidget);
if (!isOurEvent) {
return nsEventStatus_eIgnore;
aEventStatus = nsEventStatus_eIgnore;
return NS_OK;
}
switch (aEvent->message) {
@ -273,7 +286,8 @@ nsEventStatus nsInputFrame::HandleEvent(nsIPresContext& aPresContext,
mLastMouseState = eMouseNone;
break;
}
return nsEventStatus_eIgnore;
aEventStatus = nsEventStatus_eIgnore;
return NS_OK;
}

20
layout/html/forms/src/nsInputFrame.h
Просмотреть файл

@ -59,24 +59,26 @@ public:
* Respond to a gui event
* @see nsIFrame::HandleEvent
*/
virtual nsEventStatus HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent);
NS_IMETHOD HandleEvent(nsIPresContext& aPresContext,
nsGUIEvent* aEvent,
nsEventStatus& aEventStatus);
/**
* Draw this frame within the context of a presentation context and rendering context
* @see nsIFrame::Paint
*/
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/**
* Respond to the request to resize and/or reflow
* @see nsIFrame::ResizeReflow
*/
virtual ReflowStatus ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
// New Behavior

3
layout/html/forms/src/nsInputText.cpp
Просмотреть файл

@ -81,7 +81,7 @@ void
nsInputTextFrame::PreInitializeWidget(nsIPresContext* aPresContext,
nsSize& aBounds)
{
nsInputText* content = (nsInputText *)GetContent(); // this must be an nsInputButton
nsInputText* content = (nsInputText *)mContent; // this must be an nsInputButton
// get the value of the text
if (nsnull != content->mValue) {
@ -89,7 +89,6 @@ nsInputTextFrame::PreInitializeWidget(nsIPresContext* aPresContext,
} else {
mCacheValue = "";
}
NS_RELEASE(content);
float p2t = aPresContext->GetPixelsToTwips();
aBounds.width = (int)(120 * p2t);

29
layout/html/style/src/nsCSSLayout.cpp
Просмотреть файл

@ -54,8 +54,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
PRIntn kidCount = aChildCount;
while (--kidCount >= 0) {
nscoord kidAscent = *aAscents++;
nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
nsIContent* kidContent = kid->GetContent();
nsIStyleContext* kidSC;
nsIContent* kidContent;
kid->GetStyleContext(aCX, kidSC);
kid->GetContent(kidContent);
nsStyleMolecule* kidMol =
(nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
PRIntn verticalAlign = kidMol->verticalAlign;
@ -124,7 +127,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
y += kidRect.height;
if (y > maxY) maxY = y;
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
nscoord lineHeight = maxY - minY;
@ -135,8 +138,11 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
kid = aFirstChild;
while (--kidCount >= 0) {
// Get kid's vertical align style data
nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
nsIContent* kidContent = kid->GetContent();
nsIStyleContext* kidSC;
nsIContent* kidContent;
kid->GetStyleContext(aCX, kidSC);
kid->GetContent(kidContent);
nsStyleMolecule* kidMol =
(nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
PRIntn verticalAlign = kidMol->verticalAlign;
@ -154,7 +160,7 @@ nscoord nsCSSLayout::VerticallyAlignChildren(nsIPresContext* aCX,
}
}
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
@ -197,7 +203,7 @@ void nsCSSLayout::HorizontallyPlaceChildren(nsIPresContext* aCX,
while (--aChildCount >= 0) {
kid->GetOrigin(origin);
kid->MoveTo(origin.x + dx, origin.y);
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
@ -213,8 +219,11 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
nsPoint origin;
nsIFrame* kid = aFirstChild;
while (--aChildCount >= 0) {
nsIContent* kidContent = kid->GetContent();
nsIStyleContext* kidSC = kid->GetStyleContext(aCX);
nsIContent* kidContent;
nsIStyleContext* kidSC;
kid->GetContent(kidContent);
kid->GetStyleContext(aCX, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
if (NS_STYLE_POSITION_RELATIVE == kidMol->positionFlags) {
kid->GetOrigin(origin);
@ -224,6 +233,6 @@ void nsCSSLayout::RelativePositionChildren(nsIPresContext* aCX,
}
NS_RELEASE(kidContent);
NS_RELEASE(kidSC);
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}

6
layout/html/style/src/nsCSSStyleSheet.cpp
Просмотреть файл

@ -215,11 +215,13 @@ PRInt32 CSSStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
selector = selector->mNext;
nsIFrame* frame = aParentFrame;
while ((nsnull != selector) && (nsnull != frame)) { // check compound selectors
nsIContent* content = frame->GetContent();
nsIContent* content;
frame->GetContent(content);
if (SelectorMatches(selector, content)) {
selector = selector->mNext;
}
frame = frame->GetGeometricParent();
frame->GetGeometricParent(frame);
NS_RELEASE(content);
}
if (nsnull == selector) { // ran out, it matched

22
layout/html/table/src/nsCellLayoutData.cpp
Просмотреть файл

@ -83,8 +83,11 @@ void nsCellLayoutData::SetMaxElementSize(nsSize * aMaxElementSize)
**/
nsStyleMolecule* nsCellLayoutData::GetStyleMolecule()
{
if (mCellFrame != nsnull)
return (nsStyleMolecule*)mCellFrame->GetStyleData(kStyleMoleculeSID);
if (mCellFrame != nsnull) {
nsStyleMolecule* styleMol;
mCellFrame->GetStyleData(kStyleMoleculeSID, (nsStyleStruct*&)styleMol);
return styleMol;
}
return nsnull;
}
@ -398,8 +401,11 @@ nsStyleMolecule* nsCellLayoutData::FindOuterBorder( nsTableFrame* aTableFrame,
// for the parent frame is also zero
if (margin == 0)
{
nsIFrame* parentFrame = aFrame->GetGeometricParent();
nsStyleMolecule* parentStyle = (nsStyleMolecule*)aFrame->GetStyleData(kStyleMoleculeSID);
nsIFrame* parentFrame;
nsStyleMolecule* parentStyle;
aFrame->GetGeometricParent(parentFrame);
aFrame->GetStyleData(kStyleMoleculeSID, (nsStyleStruct*&)parentStyle);
// if the padding for the parent style is zero just
// recursively call this routine
@ -547,7 +553,9 @@ void nsCellLayoutData::RecalcLayoutData(nsTableFrame* aTableFrame,
nsVoidArray* aBoundaryCells[4])
{
nsStyleMolecule* cellStyle = (nsStyleMolecule*)mCellFrame->GetStyleData(kStyleMoleculeSID);
nsStyleMolecule* cellStyle;
mCellFrame->GetStyleData(kStyleMoleculeSID, (nsStyleStruct*&)cellStyle);
CalculateBorders(aTableFrame,cellStyle,aBoundaryCells);
CalculateMargins(aTableFrame,cellStyle,aBoundaryCells);
@ -558,7 +566,9 @@ void nsCellLayoutData::List(FILE* out, PRInt32 aIndent) const
{
PRInt32 indent;
nsTableCell* cell = (nsTableCell*)mCellFrame->GetContent();
nsTableCell* cell;
mCellFrame->GetContent((nsIContent*&)cell);
if (cell != nsnull)
{
for (indent = aIndent; --indent >= 0; ) fputs(" ", out);

4
layout/html/table/src/nsColLayoutData.cpp
Просмотреть файл

@ -100,7 +100,9 @@ PRInt32 nsColLayoutData::IndexOf(nsTableCell* aTableCell) const
nsTableCellFrame* frame = cellData->GetCellFrame();
if (frame != nsnull)
{
nsTableCell* cell = (nsTableCell*)frame->GetContent();
nsTableCell* cell;
frame->GetContent((nsIContent*&)cell);
if (cell == aTableCell)
{
result = index;

56
layout/html/table/src/nsTableCaptionFrame.cpp
Просмотреть файл

@ -89,14 +89,14 @@ void nsTableCaptionFrame::CreatePsuedoFrame(nsIPresContext* aPresContext)
NS_ASSERTION(prevFrame->ChildIsPseudoFrame(prevPseudoFrame), "bad previous pseudo-frame");
// Create a continuing column
mFirstChild = prevPseudoFrame->CreateContinuingFrame(aPresContext, this);
prevPseudoFrame->CreateContinuingFrame(aPresContext, this, mFirstChild);
mChildCount = 1;
}
}
void nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsStyleMolecule* myMol =
(nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@ -104,7 +104,7 @@ void nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
(nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
NS_ASSERTION(nsnull!=myColor, "bad style color");
NS_ASSERTION(nsnull!=myMol, "bad style molecule");
if (nsnull==myMol) return;
if (nsnull==myMol) return NS_OK;
nsCSSRendering::PaintBackground(aPresContext, aRenderingContext, this,
aDirtyRect, mRect, *myColor);
@ -119,6 +119,7 @@ void nsTableCaptionFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
/**
@ -142,7 +143,7 @@ void nsTableCaptionFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
bottomInset =mol->borderPadding.bottom;
verticalAlign = mol->verticalAlign;
}
nscoord height = GetHeight();
nscoord height = mRect.height;
nsRect kidRect;
mFirstChild->GetRect(kidRect);
@ -177,11 +178,11 @@ void nsTableCaptionFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
/**
*/
nsIFrame::ReflowStatus
nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_PRECONDITION(nsnull!=aPresContext, "bad arg");
@ -189,7 +190,7 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
PreReflowCheck();
#endif
ReflowStatus result = frComplete;
aStatus = frComplete;
if (gsDebug==PR_TRUE)
printf("nsTableCaptionFrame::ResizeReflow: maxSize=%d,%d\n",
aMaxSize.width, aMaxSize.height);
@ -239,7 +240,7 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
if (gsDebug==PR_TRUE)
printf(" nsTableCaptionFrame::ResizeReflow calling ReflowChild with availSize=%d,%d\n",
availSize.width, availSize.height);
result = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
aStatus = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
if (gsDebug==PR_TRUE)
{
@ -264,7 +265,7 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
kidSize.width, kidSize.height));
if (frNotComplete == result) {
if (frNotComplete == aStatus) {
// If the child didn't finish layout then it means that it used
// up all of our available space (or needs us to split).
mLastContentIsComplete = PR_FALSE;
@ -301,31 +302,32 @@ nsTableCaptionFrame::ResizeReflow(nsIPresContext* aPresContext,
aDesiredSize.width, aDesiredSize.height);
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
return result;
return NS_OK;
}
nsIFrame::ReflowStatus
nsTableCaptionFrame::IncrementalReflow( nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsTableCaptionFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug == PR_TRUE) printf("nsTableCaptionFrame::IncrementalReflow\n");
// total hack for now, just some hard-coded values
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
return frComplete;
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
return NS_OK;
}
nsIFrame* nsTableCaptionFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableCaptionFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableCaptionFrame* cf = new nsTableCaptionFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
/* ----- static methods ----- */

29
layout/html/table/src/nsTableCaptionFrame.h
Просмотреть файл

@ -38,25 +38,28 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/**
* @see nsContainerFrame
*/
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
virtual void VerticallyAlignChild(nsIPresContext* aPresContext);

55
layout/html/table/src/nsTableCellFrame.cpp
Просмотреть файл

@ -51,9 +51,9 @@ nsTableCellFrame::~nsTableCellFrame()
{
}
void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableCellFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsStyleColor* myColor =
(nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@ -75,6 +75,7 @@ void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
/**
@ -98,7 +99,7 @@ void nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
bottomInset =mol->borderPadding.bottom;
verticalAlign = mol->verticalAlign;
}
nscoord height = GetHeight();
nscoord height = mRect.height;
nsRect kidRect;
mFirstChild->GetRect(kidRect);
@ -135,11 +136,10 @@ void nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
PRInt32 nsTableCellFrame::GetRowSpan()
{
PRInt32 result = 0;
nsTableCell *cellContent = (nsTableCell *)GetContent(); // cellContent: REFCNT++
nsTableCell *cellContent = (nsTableCell *)mContent;
if (nsnull!=cellContent)
{
result = cellContent->GetRowSpan();
NS_RELEASE(cellContent); // cellContent: REFCNT--
}
return result;
}
@ -164,18 +164,18 @@ void nsTableCellFrame::CreatePsuedoFrame(nsIPresContext* aPresContext)
NS_ASSERTION(prevFrame->ChildIsPseudoFrame(prevPseudoFrame), "bad previous pseudo-frame");
// Create a continuing column
mFirstChild = prevPseudoFrame->CreateContinuingFrame(aPresContext, this);
prevPseudoFrame->CreateContinuingFrame(aPresContext, this, mFirstChild);
mChildCount = 1;
}
}
/**
*/
nsIFrame::ReflowStatus
nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_PRECONDITION(nsnull!=aPresContext, "bad arg");
@ -183,7 +183,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
//PreReflowCheck();
#endif
ReflowStatus result = frComplete;
aStatus = frComplete;
if (gsDebug==PR_TRUE)
printf("nsTableCellFrame::ResizeReflow: maxSize=%d,%d\n",
aMaxSize.width, aMaxSize.height);
@ -233,7 +233,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
if (gsDebug==PR_TRUE)
printf(" nsTableCellFrame::ResizeReflow calling ReflowChild with availSize=%d,%d\n",
availSize.width, availSize.height);
result = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
aStatus = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
if (gsDebug==PR_TRUE)
{
@ -258,7 +258,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
kidSize.width, kidSize.height));
if (frNotComplete == result) {
if (frNotComplete == aStatus) {
// If the child didn't finish layout then it means that it used
// up all of our available space (or needs us to split).
mLastContentIsComplete = PR_FALSE;
@ -289,28 +289,29 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
//PostReflowCheck(result);
#endif
return result;
return NS_OK;
}
nsIFrame::ReflowStatus
nsTableCellFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsTableCellFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug == PR_TRUE) printf("nsTableCellFrame::IncrementalReflow\n");
// total hack for now, just some hard-coded values
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
return frComplete;
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
return NS_OK;
}
nsIFrame* nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableCellFrame* cf = new nsTableCellFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}

29
layout/html/table/src/nsTableCellFrame.h
Просмотреть файл

@ -38,25 +38,28 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/**
* @see nsContainerFrame
*/
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
void VerticallyAlignChild(nsIPresContext* aPresContext);

57
layout/html/table/src/nsTableCol.cpp
Просмотреть файл

@ -42,19 +42,21 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
protected:
@ -79,20 +81,21 @@ nsTableColFrame::~nsTableColFrame()
{
}
void nsTableColFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableColFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
if (gsDebug==PR_TRUE)
printf("nsTableColFrame::Paint\n");
return NS_OK;
}
nsIFrame::ReflowStatus
nsTableColFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableColFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull!=aPresContext, "bad arg");
if (gsDebug==PR_TRUE) printf("nsTableoupFrame::ResizeReflow\n");
@ -103,20 +106,22 @@ nsTableColFrame::ResizeReflow(nsIPresContext* aPresContext,
aMaxElementSize->width=0;
aMaxElementSize->height=0;
}
return nsIFrame::frComplete;
aStatus = nsIFrame::frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
nsTableColFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsTableColFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull!=aPresContext, "bad arg");
if (gsDebug==PR_TRUE) printf("nsTableColFrame::IncrementalReflow\n");
aDesiredSize.width=0;
aDesiredSize.height=0;
return nsIFrame::frComplete;
aStatus = nsIFrame::frComplete;
return NS_OK;
}
nsresult nsTableColFrame::NewFrame(nsIFrame** aInstancePtrResult,

25
layout/html/table/src/nsTableColGroupFrame.cpp
Просмотреть файл

@ -35,20 +35,22 @@ nsTableColGroupFrame::~nsTableColGroupFrame()
{
}
void nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::Paint\n");
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull!=aPresContext, "bad arg");
if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::ResizeReflow\n");
@ -59,21 +61,20 @@ nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
aMaxElementSize->width=0;
aMaxElementSize->height=0;
}
return nsIFrame::frComplete;
aStatus = nsIFrame::frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableColGroupFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull!=aPresContext, "bad arg");
ReflowStatus status;
if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::IncrementalReflow\n");
return status;
return NS_OK;
}
nsresult nsTableColGroupFrame::NewFrame(nsIFrame** aInstancePtrResult,

24
layout/html/table/src/nsTableColGroupFrame.h
Просмотреть файл

@ -36,19 +36,21 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
protected:

244
layout/html/table/src/nsTableFrame.cpp
Просмотреть файл

@ -388,9 +388,9 @@ void nsTableFrame::ResetColumnLayoutData()
/* SEC: TODO: adjust the rect for captions */
void nsTableFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// table paint code is concerned primarily with borders and bg color
nsStyleColor* myColor =
@ -414,6 +414,7 @@ void nsTableFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
@ -444,10 +445,11 @@ PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
/** Layout the entire inner table.
*/
nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_PRECONDITION(nsnull != aPresContext, "null arg");
if (gsDebug==PR_TRUE)
@ -461,7 +463,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
PreReflowCheck();
#endif
ReflowStatus result = frComplete;
aStatus = frComplete;
PRIntervalTime startTime = PR_IntervalNow();
@ -479,7 +481,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
if (PR_FALSE==IsFirstPassValid())
{ // we treat the table as if we've never seen the layout data before
mPass = kPASS_FIRST;
result = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
aStatus = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
// check result
}
mPass = kPASS_SECOND;
@ -490,7 +492,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
// assign table width
SetTableWidth(aPresContext, tableStyleMol);
result = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
aStatus = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
PRIntervalTime endTime = PR_IntervalNow();
if (gsTiming) printf("Table reflow took %ld ticks for frame %d\n", endTime-startTime, this);
@ -503,10 +505,10 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
}
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
return result;
return NS_OK;
}
/** the first of 2 reflow passes
@ -587,7 +589,9 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
// SEC: TODO: when content is appended or deleted, be sure to clear out the frame hierarchy!!!!
nsIFrame* kidFrame = ChildAt(kidIndex);
nsIFrame* kidFrame;
ChildAt(kidIndex, kidFrame);
// if this is the first time, allocate the caption frame
if (nsnull==kidFrame)
{
@ -662,7 +666,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
}
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
// can't use SetLastContentOffset here
mLastContentOffset = contentOffset-1; // takes into account colGroup frame we're not using
if (gsDebug) printf("INNER: set last content offset to %d\n", GetLastContentOffset()); //@@@
@ -899,10 +903,14 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
nsIFrame::ReflowStatus status;
// Get top margin for this kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
if (((nsTableContent *)kid)->GetType() == nsITableContent::kTableRowGroupType)
{ // skip children that are not row groups
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
@ -960,17 +968,22 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
// Special handling for incomplete children
if (frNotComplete == status) {
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -982,7 +995,9 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
}
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -993,15 +1008,23 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
}
// Get the next child
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
// XXX talk with troy about checking for available space here
}
// Update the child count
mChildCount = childCount;
#ifdef NS_DEBUG
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
#endif
#ifdef NS_DEBUG
VerifyLastIsComplete();
@ -1067,7 +1090,9 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -1095,7 +1120,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
continue;
}
}
@ -1103,8 +1128,12 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetHeight() > aState.availSize.height) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -1134,7 +1163,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -1143,7 +1172,10 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* contentParent;
kidFrame->GetContentParent(contentParent);
if (nextInFlow == contentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -1163,13 +1195,16 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -1197,7 +1232,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1217,7 +1252,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
}
#endif
}
@ -1258,7 +1293,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
mFirstContentOffset = prev->NextChildOffset();
if (!prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
mLastContentIsComplete = PR_TRUE;
@ -1267,8 +1302,9 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsSize kidMaxElementSize;
nsSize* pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1301,7 +1337,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
NS_RELEASE(kidDel);
kidFrame->SetStyleContext(kidStyleContext);
} else {
kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
}
NS_RELEASE(kid);
NS_RELEASE(kidStyleContext);
@ -1356,7 +1392,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
}
// Update the content mapping
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
PRInt32 len = LengthOf(mFirstChild);
@ -1536,7 +1572,8 @@ PRBool nsTableFrame::AssignFixedColumnWidths(nsIPresContext* aPresContext, PRInt
// SEC: TODO -- when we have a style system, set the mol for the col
nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(0));
nsTableCellFrame *cellFrame = data->GetCellFrame();
nsTableCell *cell = (nsTableCell *)cellFrame->GetContent(); // cell: REFCNT++
nsTableCell *cell;
cellFrame->GetContent((nsIContent*&)cell); // cell: REFCNT++
nsStyleMolecule* cellStyle = (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
NS_ASSERTION(nsnull != cellStyle, "bad style for cell.");
// SEC: this is the code to replace
@ -1954,7 +1991,7 @@ void nsTableFrame::SetTableWidth(nsIPresContext* aPresContext,
nscoord rightInset = aTableStyle->borderPadding.right;
nscoord leftInset = aTableStyle->borderPadding.left;
tableWidth += (leftInset + rightInset);
nsRect tableSize = GetRect();
nsRect tableSize = mRect;
tableSize.width = tableWidth;
if (gsDebug==PR_TRUE)
{
@ -1975,16 +2012,22 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
gsDebug = PR_FALSE; // turn on debug in this method
#endif
// iterate children, tell all row groups to ShrinkWrap
PRInt32 childCount = ChildCount();
PRBool atLeastOneRowSpanningCell = PR_FALSE;
PRInt32 tableHeight = 0;
PRInt32 childCount = mChildCount;
for (PRInt32 i = 0; i < childCount; i++)
{
PRInt32 childHeight=0;
// for every child that is a rowFrame, set the row frame height = sum of row heights
nsIFrame * kidFrame = ChildAt(i); // frames are not ref counted
// XXX This is a n-squared algorithm. Use GetNextSibling() instead...
nsIFrame * kidFrame;
ChildAt(i, kidFrame); // frames are not ref counted
NS_ASSERTION(nsnull != kidFrame, "bad kid frame");
nsTableContent* kid = (nsTableContent*)(kidFrame->GetContent()); // kid: REFCNT++
nsTableContent* kid;
kidFrame->GetContent((nsIContent*&)kid); // kid: REFCNT++
NS_ASSERTION(nsnull != kid, "bad kid");
if (kid->GetType() == nsITableContent::kTableRowGroupType)
{
@ -1993,33 +2036,48 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
*/
PRInt32 rowGroupHeight = 0;
nsTableRowGroupFrame * rowGroupFrame = (nsTableRowGroupFrame *)kidFrame;
PRInt32 numRows = rowGroupFrame->ChildCount();
PRInt32 numRows;
rowGroupFrame->ChildCount(numRows);
PRInt32 *rowHeights = new PRInt32[numRows];
if (gsDebug==PR_TRUE) printf("Height Step 1...\n");
for (PRInt32 rowIndex = 0; rowIndex < numRows; rowIndex++)
{
// get the height of the tallest cell in the row (excluding cells that span rows)
nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
nsTableRowFrame *rowFrame;
rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
NS_ASSERTION(nsnull != rowFrame, "bad row frame");
rowHeights[rowIndex] = rowFrame->GetTallestChild();
rowFrame->SizeTo(rowFrame->GetWidth(), rowHeights[rowIndex]);
nsSize rowFrameSize;
rowFrame->GetSize(rowFrameSize);
rowFrame->SizeTo(rowFrameSize.width, rowHeights[rowIndex]);
rowGroupHeight += rowHeights[rowIndex];
// resize all the cells based on the rowHeight
PRInt32 numCells = rowFrame->ChildCount();
PRInt32 numCells;
rowFrame->ChildCount(numCells);
for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
{
nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
nsTableCellFrame *cellFrame;
rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
PRInt32 rowSpan = cellFrame->GetRowSpan();
if (1==rowSpan)
{
if (gsDebug==PR_TRUE) printf(" setting cell[%d,%d] height to %d\n", rowIndex, cellIndex, rowHeights[rowIndex]);
cellFrame->SizeTo(cellFrame->GetWidth(), rowHeights[rowIndex]);
nsSize cellFrameSize;
cellFrame->GetSize(cellFrameSize);
cellFrame->SizeTo(cellFrameSize.width, rowHeights[rowIndex]);
// Realign cell content based on new height
cellFrame->VerticallyAlignChild(aPresContext);
}
else
{
if (gsDebug==PR_TRUE) printf(" skipping cell[%d,%d] with a desired height of %d\n", rowIndex, cellIndex, cellFrame->GetHeight());
if (gsDebug==PR_TRUE) printf(" skipping cell[%d,%d]\n", rowIndex, cellIndex);
atLeastOneRowSpanningCell = PR_TRUE;
}
}
@ -2041,11 +2099,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
rowGroupHeight=0;
for (rowIndex = 0; rowIndex < numRows; rowIndex++)
{
nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
PRInt32 numCells = rowFrame->ChildCount();
nsTableRowFrame *rowFrame;
PRInt32 numCells;
rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
rowFrame->ChildCount(numCells);
for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
{
nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
nsTableCellFrame *cellFrame;
rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
PRInt32 rowSpan = cellFrame->GetRowSpan();
if (1<rowSpan)
{
@ -2054,10 +2117,13 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
for (PRInt32 i=0; i<rowSpan; i++)
heightOfRowsSpanned += rowHeights[i+rowIndex];
/* if the cell height fits in the rows, expand the cell height and slap it in */
if (heightOfRowsSpanned>cellFrame->GetHeight())
nsSize cellFrameSize;
cellFrame->GetSize(cellFrameSize);
if (heightOfRowsSpanned>cellFrameSize.height)
{
if (gsDebug==PR_TRUE) printf(" cell[%d,%d] fits, setting height to %d\n", rowIndex, cellIndex, heightOfRowsSpanned);
cellFrame->SizeTo(cellFrame->GetWidth(), heightOfRowsSpanned);
cellFrame->SizeTo(cellFrameSize.width, heightOfRowsSpanned);
// Realign cell content based on new height
cellFrame->VerticallyAlignChild(aPresContext);
}
@ -2066,20 +2132,28 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
*/
else
{
PRInt32 excessHeight = cellFrame->GetHeight() - heightOfRowsSpanned;
PRInt32 excessHeight = cellFrameSize.height - heightOfRowsSpanned;
PRInt32 excessHeightPerRow = excessHeight/rowSpan;
if (gsDebug==PR_TRUE) printf(" cell[%d,%d] does not fit, excessHeight = %d, excessHeightPerRow = %d\n",
rowIndex, cellIndex, excessHeight, excessHeightPerRow);
// for the rows effected...
for (i=rowIndex; i<numRows; i++)
{
nsTableRowFrame *rowFrameToBeResized = (nsTableRowFrame *)(rowGroupFrame->ChildAt(i));
nsTableRowFrame *rowFrameToBeResized;
rowGroupFrame->ChildAt(i, (nsIFrame*&)rowFrameToBeResized);
if (i<rowIndex+rowSpan)
{
rowHeights[i] += excessHeightPerRow;
if (gsDebug==PR_TRUE) printf(" rowHeight[%d] set to %d\n", i, rowHeights[i]);
rowFrameToBeResized->SizeTo(rowFrameToBeResized->GetWidth(), rowHeights[i]);
PRInt32 cellCount = rowFrameToBeResized->ChildCount();
nsSize rowFrameSize;
rowFrameToBeResized->GetSize(rowFrameSize);
rowFrameToBeResized->SizeTo(rowFrameSize.width, rowHeights[i]);
PRInt32 cellCount;
rowFrameToBeResized->ChildCount(cellCount);
for (PRInt32 j=0; j<cellCount; j++)
{
if (i==rowIndex && j==cellIndex)
@ -2087,11 +2161,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
if (gsDebug==PR_TRUE) printf(" cell[%d, %d] skipping self\n", i, j);
continue; // don't do math on myself, only the other cells I effect
}
nsTableCellFrame *frame = (nsTableCellFrame *)(rowFrameToBeResized->ChildAt(j));
nsTableCellFrame *frame;
rowFrameToBeResized->ChildAt(j, (nsIFrame*&)frame);
if (frame->GetRowSpan()==1)
{
if (gsDebug==PR_TRUE) printf(" cell[%d, %d] set height to %d\n", i, j, frame->GetHeight()+excessHeightPerRow);
frame->SizeTo(frame->GetWidth(), frame->GetHeight()+excessHeightPerRow);
nsSize frameSize;
frame->GetSize(frameSize);
if (gsDebug==PR_TRUE) printf(" cell[%d, %d] set height to %d\n", i, j, frameSize.height+excessHeightPerRow);
frame->SizeTo(frameSize.width, frameSize.height+excessHeightPerRow);
// Realign cell content based on new height
frame->VerticallyAlignChild(aPresContext);
}
@ -2101,7 +2180,9 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
// push that row down by the amount we've expanded the cell heights by
if (i>rowIndex)
{
nsRect rowRect = rowFrameToBeResized->GetRect();
nsRect rowRect;
rowFrameToBeResized->GetRect(rowRect);
rowFrameToBeResized->MoveTo(rowRect.x, rowRect.y + (excessHeightPerRow*(i-rowIndex)));
if (gsDebug==PR_TRUE) printf(" row %d moved to y-offset %d\n", i,
rowRect.y + (excessHeightPerRow*(i-rowIndex)));
@ -2113,7 +2194,11 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
rowGroupHeight += rowHeights[rowIndex];
}
if (gsDebug==PR_TRUE) printf("row group height set to %d\n", rowGroupHeight);
rowGroupFrame->SizeTo(rowGroupFrame->GetWidth(), rowGroupHeight);
nsSize rowGroupFrameSize;
rowGroupFrame->GetSize(rowGroupFrameSize);
rowGroupFrame->SizeTo(rowGroupFrameSize.width, rowGroupHeight);
tableHeight += rowGroupHeight;
}
NS_RELEASE(kid); // kid: REFCNT--
@ -2139,11 +2224,11 @@ PRBool nsTableFrame::IsProportionalWidth(nsStyleMolecule* aMol)
/**
*/
nsIFrame::ReflowStatus
nsTableFrame::IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsTableFrame::IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull != aCX, "bad arg");
if (gsDebug==PR_TRUE) printf ("nsTableFrame::IncrementalReflow: maxSize=%d,%d\n",
@ -2153,7 +2238,8 @@ nsTableFrame::IncrementalReflow(nsIPresContext* aCX,
aDesiredSize.width = mRect.width;
aDesiredSize.height = mRect.height;
return frComplete;
aStatus = frComplete;
return NS_OK;
}
void nsTableFrame::VerticallyAlignChildren(nsIPresContext* aPresContext,
@ -2294,7 +2380,9 @@ nsCellLayoutData * nsTableFrame::GetCellLayoutData(nsTableCell *aCell)
for (PRInt32 i=0; i<count; i++)
{
nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(i));
nsTableCell *cell = (nsTableCell *)(data->GetCellFrame()->GetContent()); // cell: REFCNT++
nsTableCell *cell;
data->GetCellFrame()->GetContent((nsIContent*&)cell); // cell: REFCNT++
if (cell == aCell)
{
result = data;
@ -2345,18 +2433,21 @@ PRBool nsTableFrame::AutoColumnWidths(nsStyleMolecule* aTableStyleMol)
return isAutoColumnWidths;
}
nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableFrame* cf = new nsTableFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
if (PR_TRUE==gsDebug) printf("nsTableFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
// set my width, because all frames in a table flow are the same width
// code in nsTableOuterFrame depends on this being set
cf->SetRect(nsRect(0, 0, GetWidth(), 0));
cf->SetRect(nsRect(0, 0, mRect.width, 0));
// add headers and footers to cf
nsTableFrame * firstInFlow = (nsTableFrame *)GetFirstInFlow();
PRInt32 childCount = firstInFlow->ChildCount();
PRInt32 childCount;
firstInFlow->ChildCount(childCount);
PRInt32 childIndex = 0;
for (; childIndex < childCount; childIndex++)
{
@ -2364,7 +2455,8 @@ nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
// maybe need to do this in ResizeReflow at the beginning, when we determine we are a continuing frame
}
return cf;
aContinuingFrame = cf;
return NS_OK;
}
PRInt32 nsTableFrame::GetColumnWidth(PRInt32 aColIndex)

29
layout/html/table/src/nsTableFrame.h
Просмотреть файл

@ -59,9 +59,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** inner tables are reflowed in two steps.
* <pre>
@ -81,20 +81,23 @@ public:
* @see BalanceColumnWidths
* @see nsIFrame::ResizeReflow
*/
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame::CreateContinuingFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
/** resize myself and my children according to the arcane rules of cell height magic.
* By default, the height of a cell is the max (height of cells in its row)

225
layout/html/table/src/nsTableOuterFrame.cpp
Просмотреть файл

@ -122,9 +122,9 @@ nsTableOuterFrame::~nsTableOuterFrame()
delete mBottomCaptions;
}
void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// for debug...
if (nsIFrame::GetShowFrameBorders()) {
@ -133,6 +133,7 @@ void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
PRBool nsTableOuterFrame::NeedsReflow(const nsSize& aMaxSize)
@ -163,10 +164,11 @@ void nsTableOuterFrame::SetFirstPassValid(PRBool aValidState)
* NOTE: for breaking across pages, this method has to account for table content that is not laid out
* linearly vis a vis the frames. That is, content hierarchy and the frame hierarchy do not match.
*/
nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
if (PR_TRUE==gsDebug)
printf ("***table outer frame reflow \t\t%p\n", this);
@ -185,8 +187,9 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
aMaxElementSize->height = 0;
}
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
PRBool reflowMappedOK = PR_TRUE;
aStatus = frComplete;
nsSize innerTableMaxElementSize(0,0);
// Set up our kids. They're already present, on an overflow list,
@ -201,8 +204,11 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
// at this point, we must have at least one child frame, and we must have an inner table frame
NS_ASSERTION(nsnull!=mFirstChild, "no children");
NS_ASSERTION(nsnull!=mInnerTableFrame, "no mInnerTableFrame");
if (nsnull==mFirstChild || nsnull==mInnerTableFrame) //ERROR!
return frComplete;
if (nsnull==mFirstChild || nsnull==mInnerTableFrame) {
//ERROR!
aStatus = frComplete;
return NS_OK;
}
nsStyleMolecule* tableStyleMol =
(nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@ -213,7 +219,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
if (PR_FALSE==IsFirstPassValid())
{
mFirstPassValid = PR_TRUE;
status = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
aStatus = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
}
@ -221,8 +227,8 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
if (PR_FALSE==mInnerTableFrame->IsFirstPassValid())
{ // we treat the table as if we've never seen the layout data before
mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_FIRST);
status = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize,
&innerTableMaxElementSize, tableStyleMol);
aStatus = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize,
&innerTableMaxElementSize, tableStyleMol);
#ifdef NOISY_MARGINS
nsIContent* content = mInnerTableFrame->GetContent();
@ -237,7 +243,10 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
}
mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_SECOND);
// assign table width info only if the inner table frame is a first-in-flow
if (nsnull==mInnerTableFrame->GetPrevInFlow())
nsIFrame* prevInFlow;
mInnerTableFrame->GetPrevInFlow(prevInFlow);
if (nsnull==prevInFlow)
{
// assign column widths, and assign aMaxElementSize->width
mInnerTableFrame->BalanceColumnWidths(aPresContext, tableStyleMol, aMaxSize, aMaxElementSize);
@ -245,14 +254,17 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
mInnerTableFrame->SetTableWidth(aPresContext, tableStyleMol);
}
// inner table max is now the computed width and assigned height
state.innerTableMaxSize.width = mInnerTableFrame->GetWidth();
nsSize innerTableSize;
mInnerTableFrame->GetSize(innerTableSize);
state.innerTableMaxSize.width = innerTableSize.width;
state.innerTableMaxSize.height = aMaxSize.height;
// Reflow the child frames
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
if (PR_FALSE == reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -262,7 +274,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
if (state.availSize.height <= 0) {
// No space left. Don't try to pull-up children or reflow unmapped
if (NextChildOffset() < mContent->ChildCount()) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (NextChildOffset() < mContent->ChildCount()) {
// Try and pull-up some children from a next-in-flow
@ -271,12 +283,12 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
NS_ABORT(); // huge error for tables!
} else {
// We were unable to pull-up all the existing frames from the next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there's room for it.
nscoord margin = state.prevMaxPosBottomMargin -
@ -320,7 +332,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
*/
// end REMOVE ME!
return status;
return NS_OK;
}
@ -442,7 +454,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
kidFrame, aState.processingCaption?"caption":"inner");
// Get top margin for this kid
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
@ -505,17 +519,22 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No, the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -528,7 +547,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -538,7 +559,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
}
// Get the next child
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
// XXX talk with troy about checking for available space here
}
@ -548,7 +569,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
// Set the last content offset based on the last child we mapped.
NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
@ -615,7 +636,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -644,7 +667,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
continue;
}
}
@ -652,8 +675,13 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetWidth() > aState.availSize.height) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.width > aState.availSize.height) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -678,7 +706,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
PlaceChild(aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -687,7 +715,10 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* kidContentParent;
kidFrame->GetContentParent(kidContentParent);
if (nextInFlow == kidContentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -707,13 +738,16 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -741,7 +775,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -761,7 +795,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
}
#endif
}
@ -799,7 +833,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
*/
void nsTableOuterFrame::SetReflowState(OuterTableReflowState& aState, nsIFrame* aKidFrame)
{
nsIContent *kid = aKidFrame->GetContent(); // kid: REFCNT++
nsIContent *kid;
aKidFrame->GetContent(kid); // kid: REFCNT++
nsITableContent *tableContentInterface = nsnull;
kid->QueryInterface(kITableContentIID, (void**)&tableContentInterface);// tableContentInterface: REFCNT++
if (nsnull!=tableContentInterface)
@ -832,7 +868,9 @@ nsTableOuterFrame::ReflowChild( nsIFrame* aKidFrame,
if (PR_TRUE==aState.processingCaption)
{ // it's a caption, find out if it's top or bottom
// Resolve style
nsIStyleContext* captionStyleContext = aKidFrame->GetStyleContext(aPresContext);
nsIStyleContext* captionStyleContext;
aKidFrame->GetStyleContext(aPresContext, captionStyleContext);
NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
nsStyleMolecule* captionStyle =
(nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@ -852,13 +890,16 @@ nsTableOuterFrame::ReflowChild( nsIFrame* aKidFrame,
mMinCaptionWidth, mMaxCaptionWidth);
if (frComplete == status) {
nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
aKidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull != kidNextInFlow) {
// Remove all of the childs next-in-flows. Make sure that we ask
// the right parent to do the removal (it's possible that the
// parent is not this because we are executing pullup code)
nsTableOuterFrame* parent = (nsTableOuterFrame*)
aKidFrame->GetGeometricParent();
nsTableOuterFrame* parent;
aKidFrame->GetGeometricParent((nsIFrame*&)parent);
parent->DeleteChildsNextInFlow(aKidFrame);
}
}
@ -956,7 +997,8 @@ nsTableOuterFrame::ResizeReflowCaptionsPass1(nsIPresContext* aPresContext, nsSty
nsSize maxSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
nsReflowMetrics desiredSize;
nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize);
ReflowStatus status;
captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize, status);
if (mMinCaptionWidth<maxElementSize.width)
mMinCaptionWidth = maxElementSize.width;
if (mMaxCaptionWidth<desiredSize.width)
@ -986,7 +1028,9 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext* aPresContext,
nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
// Resolve style
nsIStyleContext* captionStyleContext = captionFrame->GetStyleContext(aPresContext);
nsIStyleContext* captionStyleContext;
captionFrame->GetStyleContext(aPresContext, captionStyleContext);
NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
nsStyleMolecule* captionStyle =
(nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@ -1009,7 +1053,10 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext* aPresContext,
else
topCaptionY = NS_UNCONSTRAINEDSIZE;
mInnerTableFrame->MoveTo(0, topCaptionY);
if (0==captionFrame->GetIndexInParent())
PRInt32 captionIndexInParent;
captionFrame->GetIndexInParent(captionIndexInParent);
if (0==captionIndexInParent)
{
SetFirstContentOffset(captionFrame);
if (gsDebug) printf("OUTER: set first content offset to %d\n", GetFirstContentOffset()); //@@@
@ -1061,7 +1108,9 @@ nsTableOuterFrame::ResizeReflowBottomCaptionsPass2(nsIPresContext* aPresContext
result = nsContainerFrame::ReflowChild(captionFrame, aPresContext, desiredSize, aMaxSize, nsnull);
// place the caption
nsRect rect = captionFrame->GetRect();
nsRect rect;
captionFrame->GetRect(rect);
rect.y = bottomCaptionY;
rect.width=desiredSize.width;
rect.height=desiredSize.height;
@ -1114,27 +1163,29 @@ void nsTableOuterFrame::SetLastContentOffset(const nsIFrame* aLastChild)
}
*/
nsIFrame::ReflowStatus
NS_METHOD
nsTableOuterFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug == PR_TRUE) printf("nsTableOuterFrame::IncrementalReflow\n");
// total hack for now, just some hard-coded values
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
return frComplete;
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
return NS_OK;
}
nsIFrame* nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableOuterFrame* cf = new nsTableOuterFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
cf->SetFirstPassValid(PR_TRUE);
printf("nsTableOuterFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext* aPresContext,
@ -1169,11 +1220,12 @@ void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext* aPresContext,
NS_RELEASE(styleContext);
}
void nsTableOuterFrame::VerifyTree() const
NS_METHOD nsTableOuterFrame::VerifyTree() const
{
#ifdef NS_DEBUG
#endif
return NS_OK;
}
/**
@ -1191,28 +1243,44 @@ void nsTableOuterFrame::VerifyTree() const
*/
PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
{
NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
NS_PRECONDITION(nsnull != aChild->GetNextInFlow(), "null next-in-flow");
NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
nsIFrame* nextInFlow = aChild->GetNextInFlow();
nsTableOuterFrame* parent = (nsTableOuterFrame*)nextInFlow->GetGeometricParent();
nsIFrame* nextInFlow;
aChild->GetNextInFlow(nextInFlow);
NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
nsTableOuterFrame* parent;
nextInFlow->GetGeometricParent((nsIFrame*&)parent);
// If the next-in-flow has a next-in-flow then delete it too (and
// delete it first).
if (nsnull != nextInFlow->GetNextInFlow()) {
nsIFrame* nextNextInFlow;
nextInFlow->GetNextInFlow(nextNextInFlow);
if (nsnull != nextNextInFlow) {
parent->DeleteChildsNextInFlow(nextInFlow);
}
NS_ASSERTION((0 == nextInFlow->ChildCount()) &&
(nsnull == nextInFlow->FirstChild()),
"deleting !empty next-in-flow");
#ifdef NS_DEBUG
PRInt32 childCount;
nsIFrame* firstChild;
nextInFlow->ChildCount(childCount);
nextInFlow->FirstChild(firstChild);
NS_ASSERTION(childCount == 0, "deleting !empty next-in-flow");
NS_ASSERTION((0 == childCount) && (nsnull == firstChild), "deleting !empty next-in-flow");
#endif
// Disconnect the next-in-flow from the flow list
nextInFlow->BreakFromPrevFlow();
// Take the next-in-flow out of the parent's child list
if (parent->mFirstChild == nextInFlow) {
parent->mFirstChild = nextInFlow->GetNextSibling();
nextInFlow->GetNextSibling(parent->mFirstChild);
if (nsnull != parent->mFirstChild) {
parent->SetFirstContentOffset(parent->mFirstChild);
if (parent->IsPseudoFrame()) {
@ -1229,22 +1297,30 @@ PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
// will be repaired.
} else {
nsIFrame* nextSibling;
// Because the next-in-flow is not the first child of the parent
// we know that it shares a parent with aChild. Therefore, we need
// to capture the next-in-flow's next sibling (in case the
// next-in-flow is the last next-in-flow for aChild AND the
// next-in-flow is not the last child in parent)
NS_ASSERTION(aChild->GetGeometricParent() == parent, "screwy flow");
NS_ASSERTION(aChild->GetNextSibling() == nextInFlow, "unexpected sibling");
NS_ASSERTION(parent->IsChild(aChild), "screwy flow");
aChild->GetNextSibling(nextSibling);
NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");
aChild->SetNextSibling(nextInFlow->GetNextSibling());
nextInFlow->GetNextSibling(nextSibling);
aChild->SetNextSibling(nextSibling);
}
// Delete the next-in-flow frame and adjust it's parent's child count
nextInFlow->DeleteFrame();
parent->mChildCount--;
NS_POSTCONDITION(nsnull == aChild->GetNextInFlow(), "non null next-in-flow");
#ifdef NS_DEBUG
aChild->GetNextInFlow(nextInFlow);
NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
#endif
return PR_TRUE;
}
@ -1268,10 +1344,13 @@ void nsTableOuterFrame::CreateInnerTableFrame(nsIPresContext* aPresContext)
nsIFrame* prevInnerTable = prevOuterTable->mInnerTableFrame;
// Create a continuing column
mInnerTableFrame = (nsTableFrame *)prevInnerTable->GetNextInFlow();
prevInnerTable->GetNextInFlow((nsIFrame*&)mInnerTableFrame);
if (nsnull==mInnerTableFrame)
{
mInnerTableFrame = (nsTableFrame *)prevInnerTable->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
prevInnerTable->CreateContinuingFrame(aPresContext, this, continuingFrame);
mInnerTableFrame = (nsTableFrame*)continuingFrame;
mChildCount++;
}
}

31
layout/html/table/src/nsTableOuterFrame.h
Просмотреть файл

@ -56,9 +56,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** outer tables are reflowed in two steps.
* Step 1:, we lay out all of the captions and the inner table with
@ -85,20 +85,23 @@ public:
* @see nsTableFrame::BalanceColumnWidths
* @see nsIFrame::ResizeReflow
*/
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
/** destructor */
virtual ~nsTableOuterFrame();
@ -205,7 +208,7 @@ protected:
/** overridden here to handle special caption-table relationship
* @see nsContainerFrame::VerifyTree
*/
virtual void VerifyTree() const;
NS_IMETHOD VerifyTree() const;
/** overridden here to handle special caption-table relationship
* @see nsContainerFrame::PrepareContinuingFrame

87
layout/html/table/src/nsTableRowFrame.cpp
Просмотреть файл

@ -63,9 +63,9 @@ void nsTableRowFrame::SetMaxChildHeight(PRInt32 aChildHeight)
mTallestCell = aChildHeight;
}
void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableRowFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// for debug...
if (nsIFrame::GetShowFrameBorders()) {
@ -74,6 +74,7 @@ void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
// aDirtyRect is in our coordinate system
@ -87,7 +88,9 @@ void nsTableRowFrame::PaintChildren(nsIPresContext& aPresContext,
{
nsIFrame* kid = mFirstChild;
while (nsnull != kid) {
nsIView *pView = kid->GetView();
nsIView *pView;
kid->GetView(pView);
if (nsnull == pView) {
nsRect kidRect;
kid->GetRect(kidRect);
@ -103,10 +106,10 @@ void nsTableRowFrame::PaintChildren(nsIPresContext& aPresContext,
aRenderingContext.DrawRect(0, 0, kidRect.width, kidRect.height);
}
aRenderingContext.PopState();
}
else
} else {
NS_RELEASE(pView);
kid = kid->GetNextSibling();
}
kid->GetNextSibling(kid);
}
}
@ -129,11 +132,12 @@ are present.
* This method stacks rows horizontally according to HTML 4.0 rules.
* Rows are responsible for layout of their children.
*/
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE)
printf("nsTableRowFrame::ResizeReflow - %p with aMaxSize = %d, %d\n",
@ -145,7 +149,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
PRInt32 maxCellHeight = 0;
ResetMaxChildHeight();
ReflowStatus result = frComplete;
aStatus = frComplete;
mFirstContentOffset = mLastContentOffset = 0;
@ -165,17 +169,21 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
// Row doesn't factor in insets, the cells do that
nsTableFrame *tableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
nsTableFrame *tableFrame;
mContentParent->GetContentParent((nsIFrame*&)tableFrame);
for (;;) {
nsIContent* kid = c->ChildAt(kidIndex); // kid: REFCNT++
if (nsnull == kid) {
result = frComplete;
aStatus = frComplete;
break;
}
// get frame, creating one if needed
nsIFrame* kidFrame = ChildAt(kidIndex);
nsIFrame* kidFrame;
ChildAt(kidIndex, kidFrame);
if (nsnull==kidFrame)
{
nsIContentDelegate* kidDel;
@ -191,20 +199,24 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
NS_RELEASE(kidStyleContext);
}
nsTableCell* cell = (nsTableCell *)(kidFrame->GetContent()); // cell: ADDREF++
nsTableCell* cell;
kidFrame->GetContent((nsIContent*&)cell); // cell: ADDREF++
// Try to reflow the child into the available space.
if (NS_UNCONSTRAINEDSIZE == availSize.width)
{ // Each cell is given the entire row width to try to lay out into
result = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
result==frComplete?"complete":"NOT complete",
aStatus==frComplete?"complete":"NOT complete",
kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
nsCellLayoutData kidLayoutData((nsTableCellFrame *)kidFrame, &kidSize, &kidMaxSize);
tableFrame->SetCellLayoutData(&kidLayoutData, cell);
}
else
{ // we're in a constrained situation, so get the avail width from the known column widths
nsTableFrame *innerTableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
nsTableFrame *innerTableFrame;
mContentParent->GetContentParent((nsIFrame*&)innerTableFrame);
nsCellLayoutData *cellData = innerTableFrame->GetCellLayoutData(cell);
PRInt32 cellStartingCol = cell->GetColIndex();
PRInt32 cellColSpan = cell->GetColSpan();
@ -213,9 +225,9 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
availWidth += innerTableFrame->GetColumnWidth(cellStartingCol+numColSpan);
NS_ASSERTION(0<availWidth, "illegal width for this column");
nsSize availSizeWithSpans(availWidth, availSize.height);
result = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
result==frComplete?"complete":"NOT complete",
aStatus==frComplete?"complete":"NOT complete",
kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
// SEC: TODO: this next block could be smarter,
@ -268,7 +280,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
prevKidFrame = kidFrame;
kidIndex++;
if (frNotComplete == result) {
if (frNotComplete == aStatus) {
// If the child didn't finish layout then it means that it used
// up all of our available space (or needs us to split).
mLastContentIsComplete = PR_FALSE;
@ -278,12 +290,11 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
}
if (nsnull != prevKidFrame) {
if (LastChild()!=prevKidFrame)
if (!IsLastChild(prevKidFrame))
{
nsIFrame * frame = LastChild();
GetGeometricParent()->List();
mGeometricParent->List();
}
NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
SetLastContentOffset(prevKidFrame);
}
@ -298,46 +309,48 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
SetMaxChildHeight(maxCellHeight); // remember height of tallest child who doesn't have a row span
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
if (gsDebug1==PR_TRUE)
{
if (nsnull!=aMaxElementSize)
printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
result==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height,
aMaxElementSize->width, aMaxElementSize->height);
else
printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n",
result==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height);
}
// testing...
result = frComplete;
return result;
aStatus = frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::IncrementalReflow\n");
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame* nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::CreateContinuingFrame\n");
nsTableRowFrame* cf = new nsTableRowFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsresult nsTableRowFrame::NewFrame( nsIFrame** aInstancePtrResult,

29
layout/html/table/src/nsTableRowFrame.h
Просмотреть файл

@ -52,9 +52,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** ask all children to paint themselves, without clipping (for cells with rowspan>1)
@ -77,20 +77,23 @@ public:
* @see nsTableFrame::BalanceColumnWidths
* @see nsTableFrame::ShrinkWrapChildren
*/
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame::CreateContinuingFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
/** set mTallestCell to 0 in anticipation of recalculating it */
void ResetMaxChildHeight();

138
layout/html/table/src/nsTableRowGroupFrame.cpp
Просмотреть файл

@ -102,9 +102,9 @@ nsTableRowGroupFrame::~nsTableRowGroupFrame()
}
void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// for debug...
@ -114,6 +114,7 @@ void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
// aDirtyRect is in our coordinate system
@ -127,7 +128,9 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext& aPresContext,
{
nsIFrame* kid = mFirstChild;
while (nsnull != kid) {
nsIView *pView = kid->GetView();
nsIView *pView;
kid->GetView(pView);
if (nsnull == pView) {
nsRect kidRect;
kid->GetRect(kidRect);
@ -146,7 +149,7 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext& aPresContext,
}
else
NS_RELEASE(pView);
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
@ -257,8 +260,12 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
nsIFrame::ReflowStatus status;
// Get top margin for this kid
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
@ -331,16 +338,21 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
if (frNotComplete == status) {
// XXX It's good to assume that we might still have room
// even if the child didn't complete (floaters will want this)
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// No the child isn't complete, and it doesn't have a next in flow so
// create a continuing frame. This hooks the child into the flow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
// Insert the frame. We'll reflow it next pass through the loop
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -352,7 +364,9 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
}
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -362,15 +376,23 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
}
// Get the next child
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
// Update the child count
mChildCount = childCount;
#ifdef NS_DEBUG
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
#endif
#ifdef NS_DEBUG
VerifyLastIsComplete();
@ -436,7 +458,9 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -465,7 +489,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
continue;
}
}
@ -473,8 +497,12 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetHeight() > aState.availSize.height) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -499,7 +527,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -508,7 +536,10 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* kidContentParent;
kidFrame->GetContentParent(kidContentParent);
if (nextInFlow == kidContentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -528,13 +559,16 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -562,7 +596,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -582,7 +616,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
}
#endif
}
@ -643,7 +677,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
mFirstContentOffset = prev->NextChildOffset();
if (!prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
@ -653,7 +687,9 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsSize kidMaxElementSize;
nsSize* pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild(); // XXX remember this...
nsIFrame* prevKidFrame;
LastChild(prevKidFrame); // XXX remember this...
for (;;) {
// Get the next content object
@ -688,7 +724,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
NS_RELEASE(kidDel);
kidFrame->SetStyleContext(kidStyleContext);
} else {
kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
}
NS_RELEASE(kid);
NS_RELEASE(kidStyleContext);
@ -738,7 +774,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
}
// Update the content mapping
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
PRInt32 len = LengthOf(mFirstChild);
@ -755,11 +791,12 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
* This method stacks rows vertically according to HTML 4.0 rules.
* Rows are responsible for layout of their children.
*/
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE)
printf("nsTableRowGroupFrame::ResizeReflow - aMaxSize = %d, %d\n",
@ -774,8 +811,9 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
aMaxElementSize->height = 0;
}
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
PRBool reflowMappedOK = PR_TRUE;
aStatus = frComplete;
// Check for an overflow list
MoveOverflowToChildList();
@ -788,7 +826,7 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
if (PR_FALSE == reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -798,24 +836,24 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
if (state.availSize.height <= 0) {
// No space left. Don't try to pull-up children or reflow unmapped
if (NextChildOffset() < mContent->ChildCount()) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (NextChildOffset() < mContent->ChildCount()) {
// Try and pull-up some children from a next-in-flow
if (PullUpChildren(aPresContext, state, aMaxElementSize)) {
// If we still have unmapped children then create some new frames
if (NextChildOffset() < mContent->ChildCount()) {
status = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
aStatus = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there's room for it.
nscoord margin = state.prevMaxPosBottomMargin -
@ -832,31 +870,32 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
aDesiredSize.height = state.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
if (gsDebug1==PR_TRUE)
{
if (nsnull!=aMaxElementSize)
printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
status==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height,
aMaxElementSize->width, aMaxElementSize->height);
else
printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n",
status==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height);
}
return status;
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowGroupFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE) printf("nsTableRowGroupFrame::IncrementalReflow\n");
@ -864,16 +903,19 @@ nsTableRowGroupFrame::IncrementalReflow(nsIPresContext* aPresContext,
aDesiredSize.width = aMaxSize.width;
aDesiredSize.height = aMaxSize.height;
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame* nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableRowGroupFrame* cf = new nsTableRowGroupFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
if (PR_TRUE==gsDebug1) printf("nsTableRowGroupFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
/* ----- static methods ----- */

29
layout/html/table/src/nsTableRowGroupFrame.h
Просмотреть файл

@ -53,9 +53,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** ask all children to paint themselves, without clipping (for cells with rowspan>1)
* @see nsIFrame::Paint
@ -73,19 +73,22 @@ public:
*
* @see nsIFrame::ResizeReflow
*/
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame::CreateContinuingFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
protected:

7
layout/html/tests/TestInlineFrame.cpp
Просмотреть файл

@ -213,11 +213,13 @@ InlineFrame::InlineFrame(nsIContent* aContent,
{
}
#if 0
PRInt32 InlineFrame::MaxChildWidth()
{
PRInt32 maxWidth = 0;
for (nsIFrame* f = FirstChild(); nsnull != f; f = f->GetNextSibling()) {
nsIFrame* f;
for (FirstChild(f); nsnull != f; f->GetNextSibling(f)) {
if (f->GetWidth() > maxWidth) {
maxWidth = f->GetWidth();
}
@ -1576,9 +1578,11 @@ TestMaxElementSize(nsIPresContext* presContext)
NS_RELEASE(b);
return PR_TRUE;
}
#endif
int main(int argc, char** argv)
{
#if 0
// Create test document and presentation context
MyDocument *myDoc = new MyDocument();
nsIPresContext* presContext;
@ -1643,5 +1647,6 @@ int main(int argc, char** argv)
presContext->Release();
myDoc->Release();
#endif
return 0;
}

6
layout/style/nsCSSStyleSheet.cpp
Просмотреть файл

@ -215,11 +215,13 @@ PRInt32 CSSStyleSheetImpl::RulesMatching(nsIPresContext* aPresContext,
selector = selector->mNext;
nsIFrame* frame = aParentFrame;
while ((nsnull != selector) && (nsnull != frame)) { // check compound selectors
nsIContent* content = frame->GetContent();
nsIContent* content;
frame->GetContent(content);
if (SelectorMatches(selector, content)) {
selector = selector->mNext;
}
frame = frame->GetGeometricParent();
frame->GetGeometricParent(frame);
NS_RELEASE(content);
}
if (nsnull == selector) { // ran out, it matched

14
layout/style/nsStyleContext.cpp
Просмотреть файл

@ -526,7 +526,9 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
// It's text (!)
mMolecule.display = NS_STYLE_DISPLAY_INLINE;
mMolecule.cursor = NS_STYLE_CURSOR_IBEAM;
nsIContent* content = aParentFrame->GetContent();
nsIContent* content;
aParentFrame->GetContent(content);
nsIAtom* parentTag = content->GetTag();
parentTag->ToString(buf);
NS_RELEASE(content);
@ -539,9 +541,13 @@ void StyleContextImpl::HackStyleFor(nsIPresContext* aPresContext,
// mFont.mFont.decorations = NS_FONT_DECORATION_UNDERLINE;
// This simulates a <PRE><A>text inheritance rule
// Check the parent of the A
nsIFrame* parentParentFrame = aParentFrame->GetGeometricParent();
nsIFrame* parentParentFrame;
aParentFrame->GetGeometricParent(parentParentFrame);
if (nsnull != parentParentFrame) {
nsIContent* parentParentContent = parentParentFrame->GetContent();
nsIContent* parentParentContent;
parentParentFrame->GetContent(parentParentContent);
nsIAtom* parentParentTag = parentParentContent->GetTag();
parentParentTag->ToString(buf);
NS_RELEASE(parentParentTag);
@ -607,7 +613,7 @@ NS_NewStyleContext(nsIStyleContext** aInstancePtrResult,
nsIStyleContext* parent = nsnull;
if (nsnull != aParentFrame) {
parent = aParentFrame->GetStyleContext(aPresContext);
aParentFrame->GetStyleContext(aPresContext, parent);
NS_ASSERTION(nsnull != parent, "parent frame must have style context");
}

2
layout/style/nsStyleSet.cpp
Просмотреть файл

@ -454,7 +454,7 @@ nsIStyleContext* StyleSetImpl::ResolveStyleFor(nsIPresContext* aPresContext,
nsIStyleContext* parentContext = nsnull;
if (nsnull != aParentFrame) {
parentContext = aParentFrame->GetStyleContext(aPresContext);
aParentFrame->GetStyleContext(aPresContext, parentContext);
NS_ASSERTION(nsnull != parentContext, "parent must have style context");
}

55
layout/tables/nsTableCellFrame.cpp
Просмотреть файл

@ -51,9 +51,9 @@ nsTableCellFrame::~nsTableCellFrame()
{
}
void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableCellFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsStyleColor* myColor =
(nsStyleColor*)mStyleContext->GetData(kStyleColorSID);
@ -75,6 +75,7 @@ void nsTableCellFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
/**
@ -98,7 +99,7 @@ void nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
bottomInset =mol->borderPadding.bottom;
verticalAlign = mol->verticalAlign;
}
nscoord height = GetHeight();
nscoord height = mRect.height;
nsRect kidRect;
mFirstChild->GetRect(kidRect);
@ -135,11 +136,10 @@ void nsTableCellFrame::VerticallyAlignChild(nsIPresContext* aPresContext)
PRInt32 nsTableCellFrame::GetRowSpan()
{
PRInt32 result = 0;
nsTableCell *cellContent = (nsTableCell *)GetContent(); // cellContent: REFCNT++
nsTableCell *cellContent = (nsTableCell *)mContent;
if (nsnull!=cellContent)
{
result = cellContent->GetRowSpan();
NS_RELEASE(cellContent); // cellContent: REFCNT--
}
return result;
}
@ -164,18 +164,18 @@ void nsTableCellFrame::CreatePsuedoFrame(nsIPresContext* aPresContext)
NS_ASSERTION(prevFrame->ChildIsPseudoFrame(prevPseudoFrame), "bad previous pseudo-frame");
// Create a continuing column
mFirstChild = prevPseudoFrame->CreateContinuingFrame(aPresContext, this);
prevPseudoFrame->CreateContinuingFrame(aPresContext, this, mFirstChild);
mChildCount = 1;
}
}
/**
*/
nsIFrame::ReflowStatus
nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_PRECONDITION(nsnull!=aPresContext, "bad arg");
@ -183,7 +183,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
//PreReflowCheck();
#endif
ReflowStatus result = frComplete;
aStatus = frComplete;
if (gsDebug==PR_TRUE)
printf("nsTableCellFrame::ResizeReflow: maxSize=%d,%d\n",
aMaxSize.width, aMaxSize.height);
@ -233,7 +233,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
if (gsDebug==PR_TRUE)
printf(" nsTableCellFrame::ResizeReflow calling ReflowChild with availSize=%d,%d\n",
availSize.width, availSize.height);
result = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
aStatus = ReflowChild(mFirstChild, aPresContext, kidSize, availSize, pMaxElementSize);
if (gsDebug==PR_TRUE)
{
@ -258,7 +258,7 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
kidSize.width, kidSize.height));
if (frNotComplete == result) {
if (frNotComplete == aStatus) {
// If the child didn't finish layout then it means that it used
// up all of our available space (or needs us to split).
mLastContentIsComplete = PR_FALSE;
@ -289,28 +289,29 @@ nsTableCellFrame::ResizeReflow(nsIPresContext* aPresContext,
//PostReflowCheck(result);
#endif
return result;
return NS_OK;
}
nsIFrame::ReflowStatus
nsTableCellFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsTableCellFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug == PR_TRUE) printf("nsTableCellFrame::IncrementalReflow\n");
// total hack for now, just some hard-coded values
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
return frComplete;
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
return NS_OK;
}
nsIFrame* nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableCellFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableCellFrame* cf = new nsTableCellFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}

29
layout/tables/nsTableCellFrame.h
Просмотреть файл

@ -38,25 +38,28 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/**
* @see nsContainerFrame
*/
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
void VerticallyAlignChild(nsIPresContext* aPresContext);

25
layout/tables/nsTableColGroupFrame.cpp
Просмотреть файл

@ -35,20 +35,22 @@ nsTableColGroupFrame::~nsTableColGroupFrame()
{
}
void nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableColGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::Paint\n");
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull!=aPresContext, "bad arg");
if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::ResizeReflow\n");
@ -59,21 +61,20 @@ nsTableColGroupFrame::ResizeReflow(nsIPresContext* aPresContext,
aMaxElementSize->width=0;
aMaxElementSize->height=0;
}
return nsIFrame::frComplete;
aStatus = nsIFrame::frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableColGroupFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull!=aPresContext, "bad arg");
ReflowStatus status;
if (gsDebug==PR_TRUE) printf("nsTableColGroupFrame::IncrementalReflow\n");
return status;
return NS_OK;
}
nsresult nsTableColGroupFrame::NewFrame(nsIFrame** aInstancePtrResult,

24
layout/tables/nsTableColGroupFrame.h
Просмотреть файл

@ -36,19 +36,21 @@ public:
PRInt32 aIndexInParent,
nsIFrame* aParent);
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
protected:

244
layout/tables/nsTableFrame.cpp
Просмотреть файл

@ -388,9 +388,9 @@ void nsTableFrame::ResetColumnLayoutData()
/* SEC: TODO: adjust the rect for captions */
void nsTableFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// table paint code is concerned primarily with borders and bg color
nsStyleColor* myColor =
@ -414,6 +414,7 @@ void nsTableFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
@ -444,10 +445,11 @@ PRBool nsTableFrame::NeedsReflow(const nsSize& aMaxSize)
/** Layout the entire inner table.
*/
nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
NS_PRECONDITION(nsnull != aPresContext, "null arg");
if (gsDebug==PR_TRUE)
@ -461,7 +463,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
PreReflowCheck();
#endif
ReflowStatus result = frComplete;
aStatus = frComplete;
PRIntervalTime startTime = PR_IntervalNow();
@ -479,7 +481,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
if (PR_FALSE==IsFirstPassValid())
{ // we treat the table as if we've never seen the layout data before
mPass = kPASS_FIRST;
result = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
aStatus = ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol);
// check result
}
mPass = kPASS_SECOND;
@ -490,7 +492,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
// assign table width
SetTableWidth(aPresContext, tableStyleMol);
result = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
aStatus = ResizeReflowPass2(aPresContext, aDesiredSize, aMaxSize, aMaxElementSize, tableStyleMol, 0, 0);
PRIntervalTime endTime = PR_IntervalNow();
if (gsTiming) printf("Table reflow took %ld ticks for frame %d\n", endTime-startTime, this);
@ -503,10 +505,10 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflow( nsIPresContext* aPresContext,
}
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
return result;
return NS_OK;
}
/** the first of 2 reflow passes
@ -587,7 +589,9 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
// SEC: TODO: when content is appended or deleted, be sure to clear out the frame hierarchy!!!!
nsIFrame* kidFrame = ChildAt(kidIndex);
nsIFrame* kidFrame;
ChildAt(kidIndex, kidFrame);
// if this is the first time, allocate the caption frame
if (nsnull==kidFrame)
{
@ -662,7 +666,7 @@ nsIFrame::ReflowStatus nsTableFrame::ResizeReflowPass1(nsIPresContext* aPresCont
}
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
// can't use SetLastContentOffset here
mLastContentOffset = contentOffset-1; // takes into account colGroup frame we're not using
if (gsDebug) printf("INNER: set last content offset to %d\n", GetLastContentOffset()); //@@@
@ -899,10 +903,14 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
nsIFrame::ReflowStatus status;
// Get top margin for this kid
nsIContent* kid = kidFrame->GetContent();
nsIContent* kid;
kidFrame->GetContent(kid);
if (((nsTableContent *)kid)->GetType() == nsITableContent::kTableRowGroupType)
{ // skip children that are not row groups
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
@ -960,17 +968,22 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
// Special handling for incomplete children
if (frNotComplete == status) {
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -982,7 +995,9 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
}
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -993,15 +1008,23 @@ PRBool nsTableFrame::ReflowMappedChildren( nsIPresContext* aPresContext,
}
// Get the next child
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
// XXX talk with troy about checking for available space here
}
// Update the child count
mChildCount = childCount;
#ifdef NS_DEBUG
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
#endif
#ifdef NS_DEBUG
VerifyLastIsComplete();
@ -1067,7 +1090,9 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -1095,7 +1120,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
continue;
}
}
@ -1103,8 +1128,12 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetHeight() > aState.availSize.height) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -1134,7 +1163,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -1143,7 +1172,10 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* contentParent;
kidFrame->GetContentParent(contentParent);
if (nextInFlow == contentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -1163,13 +1195,16 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -1197,7 +1232,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -1217,7 +1252,7 @@ PRBool nsTableFrame::PullUpChildren(nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsTableFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
}
#endif
}
@ -1258,7 +1293,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
mFirstContentOffset = prev->NextChildOffset();
if (!prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
mLastContentIsComplete = PR_TRUE;
@ -1267,8 +1302,9 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsSize kidMaxElementSize;
nsSize* pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
for (;;) {
// Get the next content object
nsIContent* kid = mContent->ChildAt(kidIndex);
@ -1301,7 +1337,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
NS_RELEASE(kidDel);
kidFrame->SetStyleContext(kidStyleContext);
} else {
kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
}
NS_RELEASE(kid);
NS_RELEASE(kidStyleContext);
@ -1356,7 +1392,7 @@ nsTableFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
}
// Update the content mapping
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
PRInt32 len = LengthOf(mFirstChild);
@ -1536,7 +1572,8 @@ PRBool nsTableFrame::AssignFixedColumnWidths(nsIPresContext* aPresContext, PRInt
// SEC: TODO -- when we have a style system, set the mol for the col
nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(0));
nsTableCellFrame *cellFrame = data->GetCellFrame();
nsTableCell *cell = (nsTableCell *)cellFrame->GetContent(); // cell: REFCNT++
nsTableCell *cell;
cellFrame->GetContent((nsIContent*&)cell); // cell: REFCNT++
nsStyleMolecule* cellStyle = (nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
NS_ASSERTION(nsnull != cellStyle, "bad style for cell.");
// SEC: this is the code to replace
@ -1954,7 +1991,7 @@ void nsTableFrame::SetTableWidth(nsIPresContext* aPresContext,
nscoord rightInset = aTableStyle->borderPadding.right;
nscoord leftInset = aTableStyle->borderPadding.left;
tableWidth += (leftInset + rightInset);
nsRect tableSize = GetRect();
nsRect tableSize = mRect;
tableSize.width = tableWidth;
if (gsDebug==PR_TRUE)
{
@ -1975,16 +2012,22 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
gsDebug = PR_FALSE; // turn on debug in this method
#endif
// iterate children, tell all row groups to ShrinkWrap
PRInt32 childCount = ChildCount();
PRBool atLeastOneRowSpanningCell = PR_FALSE;
PRInt32 tableHeight = 0;
PRInt32 childCount = mChildCount;
for (PRInt32 i = 0; i < childCount; i++)
{
PRInt32 childHeight=0;
// for every child that is a rowFrame, set the row frame height = sum of row heights
nsIFrame * kidFrame = ChildAt(i); // frames are not ref counted
// XXX This is a n-squared algorithm. Use GetNextSibling() instead...
nsIFrame * kidFrame;
ChildAt(i, kidFrame); // frames are not ref counted
NS_ASSERTION(nsnull != kidFrame, "bad kid frame");
nsTableContent* kid = (nsTableContent*)(kidFrame->GetContent()); // kid: REFCNT++
nsTableContent* kid;
kidFrame->GetContent((nsIContent*&)kid); // kid: REFCNT++
NS_ASSERTION(nsnull != kid, "bad kid");
if (kid->GetType() == nsITableContent::kTableRowGroupType)
{
@ -1993,33 +2036,48 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
*/
PRInt32 rowGroupHeight = 0;
nsTableRowGroupFrame * rowGroupFrame = (nsTableRowGroupFrame *)kidFrame;
PRInt32 numRows = rowGroupFrame->ChildCount();
PRInt32 numRows;
rowGroupFrame->ChildCount(numRows);
PRInt32 *rowHeights = new PRInt32[numRows];
if (gsDebug==PR_TRUE) printf("Height Step 1...\n");
for (PRInt32 rowIndex = 0; rowIndex < numRows; rowIndex++)
{
// get the height of the tallest cell in the row (excluding cells that span rows)
nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
nsTableRowFrame *rowFrame;
rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
NS_ASSERTION(nsnull != rowFrame, "bad row frame");
rowHeights[rowIndex] = rowFrame->GetTallestChild();
rowFrame->SizeTo(rowFrame->GetWidth(), rowHeights[rowIndex]);
nsSize rowFrameSize;
rowFrame->GetSize(rowFrameSize);
rowFrame->SizeTo(rowFrameSize.width, rowHeights[rowIndex]);
rowGroupHeight += rowHeights[rowIndex];
// resize all the cells based on the rowHeight
PRInt32 numCells = rowFrame->ChildCount();
PRInt32 numCells;
rowFrame->ChildCount(numCells);
for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
{
nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
nsTableCellFrame *cellFrame;
rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
PRInt32 rowSpan = cellFrame->GetRowSpan();
if (1==rowSpan)
{
if (gsDebug==PR_TRUE) printf(" setting cell[%d,%d] height to %d\n", rowIndex, cellIndex, rowHeights[rowIndex]);
cellFrame->SizeTo(cellFrame->GetWidth(), rowHeights[rowIndex]);
nsSize cellFrameSize;
cellFrame->GetSize(cellFrameSize);
cellFrame->SizeTo(cellFrameSize.width, rowHeights[rowIndex]);
// Realign cell content based on new height
cellFrame->VerticallyAlignChild(aPresContext);
}
else
{
if (gsDebug==PR_TRUE) printf(" skipping cell[%d,%d] with a desired height of %d\n", rowIndex, cellIndex, cellFrame->GetHeight());
if (gsDebug==PR_TRUE) printf(" skipping cell[%d,%d]\n", rowIndex, cellIndex);
atLeastOneRowSpanningCell = PR_TRUE;
}
}
@ -2041,11 +2099,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
rowGroupHeight=0;
for (rowIndex = 0; rowIndex < numRows; rowIndex++)
{
nsTableRowFrame *rowFrame = (nsTableRowFrame *)(rowGroupFrame->ChildAt(rowIndex));
PRInt32 numCells = rowFrame->ChildCount();
nsTableRowFrame *rowFrame;
PRInt32 numCells;
rowGroupFrame->ChildAt(rowIndex, (nsIFrame*&)rowFrame);
rowFrame->ChildCount(numCells);
for (PRInt32 cellIndex = 0; cellIndex < numCells; cellIndex++)
{
nsTableCellFrame *cellFrame = (nsTableCellFrame *)(rowFrame->ChildAt(cellIndex));
nsTableCellFrame *cellFrame;
rowFrame->ChildAt(cellIndex, (nsIFrame*&)cellFrame);
PRInt32 rowSpan = cellFrame->GetRowSpan();
if (1<rowSpan)
{
@ -2054,10 +2117,13 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
for (PRInt32 i=0; i<rowSpan; i++)
heightOfRowsSpanned += rowHeights[i+rowIndex];
/* if the cell height fits in the rows, expand the cell height and slap it in */
if (heightOfRowsSpanned>cellFrame->GetHeight())
nsSize cellFrameSize;
cellFrame->GetSize(cellFrameSize);
if (heightOfRowsSpanned>cellFrameSize.height)
{
if (gsDebug==PR_TRUE) printf(" cell[%d,%d] fits, setting height to %d\n", rowIndex, cellIndex, heightOfRowsSpanned);
cellFrame->SizeTo(cellFrame->GetWidth(), heightOfRowsSpanned);
cellFrame->SizeTo(cellFrameSize.width, heightOfRowsSpanned);
// Realign cell content based on new height
cellFrame->VerticallyAlignChild(aPresContext);
}
@ -2066,20 +2132,28 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
*/
else
{
PRInt32 excessHeight = cellFrame->GetHeight() - heightOfRowsSpanned;
PRInt32 excessHeight = cellFrameSize.height - heightOfRowsSpanned;
PRInt32 excessHeightPerRow = excessHeight/rowSpan;
if (gsDebug==PR_TRUE) printf(" cell[%d,%d] does not fit, excessHeight = %d, excessHeightPerRow = %d\n",
rowIndex, cellIndex, excessHeight, excessHeightPerRow);
// for the rows effected...
for (i=rowIndex; i<numRows; i++)
{
nsTableRowFrame *rowFrameToBeResized = (nsTableRowFrame *)(rowGroupFrame->ChildAt(i));
nsTableRowFrame *rowFrameToBeResized;
rowGroupFrame->ChildAt(i, (nsIFrame*&)rowFrameToBeResized);
if (i<rowIndex+rowSpan)
{
rowHeights[i] += excessHeightPerRow;
if (gsDebug==PR_TRUE) printf(" rowHeight[%d] set to %d\n", i, rowHeights[i]);
rowFrameToBeResized->SizeTo(rowFrameToBeResized->GetWidth(), rowHeights[i]);
PRInt32 cellCount = rowFrameToBeResized->ChildCount();
nsSize rowFrameSize;
rowFrameToBeResized->GetSize(rowFrameSize);
rowFrameToBeResized->SizeTo(rowFrameSize.width, rowHeights[i]);
PRInt32 cellCount;
rowFrameToBeResized->ChildCount(cellCount);
for (PRInt32 j=0; j<cellCount; j++)
{
if (i==rowIndex && j==cellIndex)
@ -2087,11 +2161,16 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
if (gsDebug==PR_TRUE) printf(" cell[%d, %d] skipping self\n", i, j);
continue; // don't do math on myself, only the other cells I effect
}
nsTableCellFrame *frame = (nsTableCellFrame *)(rowFrameToBeResized->ChildAt(j));
nsTableCellFrame *frame;
rowFrameToBeResized->ChildAt(j, (nsIFrame*&)frame);
if (frame->GetRowSpan()==1)
{
if (gsDebug==PR_TRUE) printf(" cell[%d, %d] set height to %d\n", i, j, frame->GetHeight()+excessHeightPerRow);
frame->SizeTo(frame->GetWidth(), frame->GetHeight()+excessHeightPerRow);
nsSize frameSize;
frame->GetSize(frameSize);
if (gsDebug==PR_TRUE) printf(" cell[%d, %d] set height to %d\n", i, j, frameSize.height+excessHeightPerRow);
frame->SizeTo(frameSize.width, frameSize.height+excessHeightPerRow);
// Realign cell content based on new height
frame->VerticallyAlignChild(aPresContext);
}
@ -2101,7 +2180,9 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
// push that row down by the amount we've expanded the cell heights by
if (i>rowIndex)
{
nsRect rowRect = rowFrameToBeResized->GetRect();
nsRect rowRect;
rowFrameToBeResized->GetRect(rowRect);
rowFrameToBeResized->MoveTo(rowRect.x, rowRect.y + (excessHeightPerRow*(i-rowIndex)));
if (gsDebug==PR_TRUE) printf(" row %d moved to y-offset %d\n", i,
rowRect.y + (excessHeightPerRow*(i-rowIndex)));
@ -2113,7 +2194,11 @@ void nsTableFrame::ShrinkWrapChildren(nsIPresContext* aPresContext,
rowGroupHeight += rowHeights[rowIndex];
}
if (gsDebug==PR_TRUE) printf("row group height set to %d\n", rowGroupHeight);
rowGroupFrame->SizeTo(rowGroupFrame->GetWidth(), rowGroupHeight);
nsSize rowGroupFrameSize;
rowGroupFrame->GetSize(rowGroupFrameSize);
rowGroupFrame->SizeTo(rowGroupFrameSize.width, rowGroupHeight);
tableHeight += rowGroupHeight;
}
NS_RELEASE(kid); // kid: REFCNT--
@ -2139,11 +2224,11 @@ PRBool nsTableFrame::IsProportionalWidth(nsStyleMolecule* aMol)
/**
*/
nsIFrame::ReflowStatus
nsTableFrame::IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
NS_METHOD nsTableFrame::IncrementalReflow(nsIPresContext* aCX,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
NS_ASSERTION(nsnull != aCX, "bad arg");
if (gsDebug==PR_TRUE) printf ("nsTableFrame::IncrementalReflow: maxSize=%d,%d\n",
@ -2153,7 +2238,8 @@ nsTableFrame::IncrementalReflow(nsIPresContext* aCX,
aDesiredSize.width = mRect.width;
aDesiredSize.height = mRect.height;
return frComplete;
aStatus = frComplete;
return NS_OK;
}
void nsTableFrame::VerticallyAlignChildren(nsIPresContext* aPresContext,
@ -2294,7 +2380,9 @@ nsCellLayoutData * nsTableFrame::GetCellLayoutData(nsTableCell *aCell)
for (PRInt32 i=0; i<count; i++)
{
nsCellLayoutData * data = (nsCellLayoutData *)(cells->ElementAt(i));
nsTableCell *cell = (nsTableCell *)(data->GetCellFrame()->GetContent()); // cell: REFCNT++
nsTableCell *cell;
data->GetCellFrame()->GetContent((nsIContent*&)cell); // cell: REFCNT++
if (cell == aCell)
{
result = data;
@ -2345,18 +2433,21 @@ PRBool nsTableFrame::AutoColumnWidths(nsStyleMolecule* aTableStyleMol)
return isAutoColumnWidths;
}
nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableFrame* cf = new nsTableFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
if (PR_TRUE==gsDebug) printf("nsTableFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
// set my width, because all frames in a table flow are the same width
// code in nsTableOuterFrame depends on this being set
cf->SetRect(nsRect(0, 0, GetWidth(), 0));
cf->SetRect(nsRect(0, 0, mRect.width, 0));
// add headers and footers to cf
nsTableFrame * firstInFlow = (nsTableFrame *)GetFirstInFlow();
PRInt32 childCount = firstInFlow->ChildCount();
PRInt32 childCount;
firstInFlow->ChildCount(childCount);
PRInt32 childIndex = 0;
for (; childIndex < childCount; childIndex++)
{
@ -2364,7 +2455,8 @@ nsIFrame* nsTableFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
// maybe need to do this in ResizeReflow at the beginning, when we determine we are a continuing frame
}
return cf;
aContinuingFrame = cf;
return NS_OK;
}
PRInt32 nsTableFrame::GetColumnWidth(PRInt32 aColIndex)

29
layout/tables/nsTableFrame.h
Просмотреть файл

@ -59,9 +59,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** inner tables are reflowed in two steps.
* <pre>
@ -81,20 +81,23 @@ public:
* @see BalanceColumnWidths
* @see nsIFrame::ResizeReflow
*/
virtual ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
virtual ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame::CreateContinuingFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
/** resize myself and my children according to the arcane rules of cell height magic.
* By default, the height of a cell is the max (height of cells in its row)

225
layout/tables/nsTableOuterFrame.cpp
Просмотреть файл

@ -122,9 +122,9 @@ nsTableOuterFrame::~nsTableOuterFrame()
delete mBottomCaptions;
}
void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// for debug...
if (nsIFrame::GetShowFrameBorders()) {
@ -133,6 +133,7 @@ void nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
PRBool nsTableOuterFrame::NeedsReflow(const nsSize& aMaxSize)
@ -163,10 +164,11 @@ void nsTableOuterFrame::SetFirstPassValid(PRBool aValidState)
* NOTE: for breaking across pages, this method has to account for table content that is not laid out
* linearly vis a vis the frames. That is, content hierarchy and the frame hierarchy do not match.
*/
nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
NS_METHOD nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
if (PR_TRUE==gsDebug)
printf ("***table outer frame reflow \t\t%p\n", this);
@ -185,8 +187,9 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
aMaxElementSize->height = 0;
}
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
PRBool reflowMappedOK = PR_TRUE;
aStatus = frComplete;
nsSize innerTableMaxElementSize(0,0);
// Set up our kids. They're already present, on an overflow list,
@ -201,8 +204,11 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
// at this point, we must have at least one child frame, and we must have an inner table frame
NS_ASSERTION(nsnull!=mFirstChild, "no children");
NS_ASSERTION(nsnull!=mInnerTableFrame, "no mInnerTableFrame");
if (nsnull==mFirstChild || nsnull==mInnerTableFrame) //ERROR!
return frComplete;
if (nsnull==mFirstChild || nsnull==mInnerTableFrame) {
//ERROR!
aStatus = frComplete;
return NS_OK;
}
nsStyleMolecule* tableStyleMol =
(nsStyleMolecule*)mStyleContext->GetData(kStyleMoleculeSID);
@ -213,7 +219,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
if (PR_FALSE==IsFirstPassValid())
{
mFirstPassValid = PR_TRUE;
status = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
aStatus = ResizeReflowCaptionsPass1(aPresContext, tableStyleMol);
}
@ -221,8 +227,8 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
if (PR_FALSE==mInnerTableFrame->IsFirstPassValid())
{ // we treat the table as if we've never seen the layout data before
mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_FIRST);
status = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize,
&innerTableMaxElementSize, tableStyleMol);
aStatus = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize, aMaxSize,
&innerTableMaxElementSize, tableStyleMol);
#ifdef NOISY_MARGINS
nsIContent* content = mInnerTableFrame->GetContent();
@ -237,7 +243,10 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
}
mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_SECOND);
// assign table width info only if the inner table frame is a first-in-flow
if (nsnull==mInnerTableFrame->GetPrevInFlow())
nsIFrame* prevInFlow;
mInnerTableFrame->GetPrevInFlow(prevInFlow);
if (nsnull==prevInFlow)
{
// assign column widths, and assign aMaxElementSize->width
mInnerTableFrame->BalanceColumnWidths(aPresContext, tableStyleMol, aMaxSize, aMaxElementSize);
@ -245,14 +254,17 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
mInnerTableFrame->SetTableWidth(aPresContext, tableStyleMol);
}
// inner table max is now the computed width and assigned height
state.innerTableMaxSize.width = mInnerTableFrame->GetWidth();
nsSize innerTableSize;
mInnerTableFrame->GetSize(innerTableSize);
state.innerTableMaxSize.width = innerTableSize.width;
state.innerTableMaxSize.height = aMaxSize.height;
// Reflow the child frames
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
if (PR_FALSE == reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -262,7 +274,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
if (state.availSize.height <= 0) {
// No space left. Don't try to pull-up children or reflow unmapped
if (NextChildOffset() < mContent->ChildCount()) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (NextChildOffset() < mContent->ChildCount()) {
// Try and pull-up some children from a next-in-flow
@ -271,12 +283,12 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
NS_ABORT(); // huge error for tables!
} else {
// We were unable to pull-up all the existing frames from the next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there's room for it.
nscoord margin = state.prevMaxPosBottomMargin -
@ -320,7 +332,7 @@ nsIFrame::ReflowStatus nsTableOuterFrame::ResizeReflow(nsIPresContext* aPresCont
*/
// end REMOVE ME!
return status;
return NS_OK;
}
@ -442,7 +454,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
kidFrame, aState.processingCaption?"caption":"inner");
// Get top margin for this kid
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
@ -505,17 +519,22 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No, the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a continuing
// frame. This hooks the child into the flow
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to the sibling list
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -528,7 +547,9 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -538,7 +559,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
}
// Get the next child
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
// XXX talk with troy about checking for available space here
}
@ -548,7 +569,7 @@ PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext* aPresContex
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
// Set the last content offset based on the last child we mapped.
NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
@ -615,7 +636,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -644,7 +667,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
continue;
}
}
@ -652,8 +675,13 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetWidth() > aState.availSize.height) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.width > aState.availSize.height) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -678,7 +706,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
PlaceChild(aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -687,7 +715,10 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* kidContentParent;
kidFrame->GetContentParent(kidContentParent);
if (nextInFlow == kidContentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -707,13 +738,16 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -741,7 +775,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -761,7 +795,7 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsTableOuterFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
}
#endif
}
@ -799,7 +833,9 @@ PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext* aPresContext,
*/
void nsTableOuterFrame::SetReflowState(OuterTableReflowState& aState, nsIFrame* aKidFrame)
{
nsIContent *kid = aKidFrame->GetContent(); // kid: REFCNT++
nsIContent *kid;
aKidFrame->GetContent(kid); // kid: REFCNT++
nsITableContent *tableContentInterface = nsnull;
kid->QueryInterface(kITableContentIID, (void**)&tableContentInterface);// tableContentInterface: REFCNT++
if (nsnull!=tableContentInterface)
@ -832,7 +868,9 @@ nsTableOuterFrame::ReflowChild( nsIFrame* aKidFrame,
if (PR_TRUE==aState.processingCaption)
{ // it's a caption, find out if it's top or bottom
// Resolve style
nsIStyleContext* captionStyleContext = aKidFrame->GetStyleContext(aPresContext);
nsIStyleContext* captionStyleContext;
aKidFrame->GetStyleContext(aPresContext, captionStyleContext);
NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
nsStyleMolecule* captionStyle =
(nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@ -852,13 +890,16 @@ nsTableOuterFrame::ReflowChild( nsIFrame* aKidFrame,
mMinCaptionWidth, mMaxCaptionWidth);
if (frComplete == status) {
nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
aKidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull != kidNextInFlow) {
// Remove all of the childs next-in-flows. Make sure that we ask
// the right parent to do the removal (it's possible that the
// parent is not this because we are executing pullup code)
nsTableOuterFrame* parent = (nsTableOuterFrame*)
aKidFrame->GetGeometricParent();
nsTableOuterFrame* parent;
aKidFrame->GetGeometricParent((nsIFrame*&)parent);
parent->DeleteChildsNextInFlow(aKidFrame);
}
}
@ -956,7 +997,8 @@ nsTableOuterFrame::ResizeReflowCaptionsPass1(nsIPresContext* aPresContext, nsSty
nsSize maxSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
nsReflowMetrics desiredSize;
nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize);
ReflowStatus status;
captionFrame->ResizeReflow(aPresContext, desiredSize, maxSize, &maxElementSize, status);
if (mMinCaptionWidth<maxElementSize.width)
mMinCaptionWidth = maxElementSize.width;
if (mMaxCaptionWidth<desiredSize.width)
@ -986,7 +1028,9 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext* aPresContext,
nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
// Resolve style
nsIStyleContext* captionStyleContext = captionFrame->GetStyleContext(aPresContext);
nsIStyleContext* captionStyleContext;
captionFrame->GetStyleContext(aPresContext, captionStyleContext);
NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
nsStyleMolecule* captionStyle =
(nsStyleMolecule*)captionStyleContext->GetData(kStyleMoleculeSID);
@ -1009,7 +1053,10 @@ nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext* aPresContext,
else
topCaptionY = NS_UNCONSTRAINEDSIZE;
mInnerTableFrame->MoveTo(0, topCaptionY);
if (0==captionFrame->GetIndexInParent())
PRInt32 captionIndexInParent;
captionFrame->GetIndexInParent(captionIndexInParent);
if (0==captionIndexInParent)
{
SetFirstContentOffset(captionFrame);
if (gsDebug) printf("OUTER: set first content offset to %d\n", GetFirstContentOffset()); //@@@
@ -1061,7 +1108,9 @@ nsTableOuterFrame::ResizeReflowBottomCaptionsPass2(nsIPresContext* aPresContext
result = nsContainerFrame::ReflowChild(captionFrame, aPresContext, desiredSize, aMaxSize, nsnull);
// place the caption
nsRect rect = captionFrame->GetRect();
nsRect rect;
captionFrame->GetRect(rect);
rect.y = bottomCaptionY;
rect.width=desiredSize.width;
rect.height=desiredSize.height;
@ -1114,27 +1163,29 @@ void nsTableOuterFrame::SetLastContentOffset(const nsIFrame* aLastChild)
}
*/
nsIFrame::ReflowStatus
NS_METHOD
nsTableOuterFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug == PR_TRUE) printf("nsTableOuterFrame::IncrementalReflow\n");
// total hack for now, just some hard-coded values
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull);
return frComplete;
ResizeReflow(aPresContext, aDesiredSize, aMaxSize, nsnull, aStatus);
return NS_OK;
}
nsIFrame* nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableOuterFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableOuterFrame* cf = new nsTableOuterFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
cf->SetFirstPassValid(PR_TRUE);
printf("nsTableOuterFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext* aPresContext,
@ -1169,11 +1220,12 @@ void nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext* aPresContext,
NS_RELEASE(styleContext);
}
void nsTableOuterFrame::VerifyTree() const
NS_METHOD nsTableOuterFrame::VerifyTree() const
{
#ifdef NS_DEBUG
#endif
return NS_OK;
}
/**
@ -1191,28 +1243,44 @@ void nsTableOuterFrame::VerifyTree() const
*/
PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
{
NS_PRECONDITION(aChild->GetGeometricParent() == (nsIFrame*)this, "bad geometric parent");
NS_PRECONDITION(nsnull != aChild->GetNextInFlow(), "null next-in-flow");
NS_PRECONDITION(IsChild(aChild), "bad geometric parent");
nsIFrame* nextInFlow = aChild->GetNextInFlow();
nsTableOuterFrame* parent = (nsTableOuterFrame*)nextInFlow->GetGeometricParent();
nsIFrame* nextInFlow;
aChild->GetNextInFlow(nextInFlow);
NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
nsTableOuterFrame* parent;
nextInFlow->GetGeometricParent((nsIFrame*&)parent);
// If the next-in-flow has a next-in-flow then delete it too (and
// delete it first).
if (nsnull != nextInFlow->GetNextInFlow()) {
nsIFrame* nextNextInFlow;
nextInFlow->GetNextInFlow(nextNextInFlow);
if (nsnull != nextNextInFlow) {
parent->DeleteChildsNextInFlow(nextInFlow);
}
NS_ASSERTION((0 == nextInFlow->ChildCount()) &&
(nsnull == nextInFlow->FirstChild()),
"deleting !empty next-in-flow");
#ifdef NS_DEBUG
PRInt32 childCount;
nsIFrame* firstChild;
nextInFlow->ChildCount(childCount);
nextInFlow->FirstChild(firstChild);
NS_ASSERTION(childCount == 0, "deleting !empty next-in-flow");
NS_ASSERTION((0 == childCount) && (nsnull == firstChild), "deleting !empty next-in-flow");
#endif
// Disconnect the next-in-flow from the flow list
nextInFlow->BreakFromPrevFlow();
// Take the next-in-flow out of the parent's child list
if (parent->mFirstChild == nextInFlow) {
parent->mFirstChild = nextInFlow->GetNextSibling();
nextInFlow->GetNextSibling(parent->mFirstChild);
if (nsnull != parent->mFirstChild) {
parent->SetFirstContentOffset(parent->mFirstChild);
if (parent->IsPseudoFrame()) {
@ -1229,22 +1297,30 @@ PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
// will be repaired.
} else {
nsIFrame* nextSibling;
// Because the next-in-flow is not the first child of the parent
// we know that it shares a parent with aChild. Therefore, we need
// to capture the next-in-flow's next sibling (in case the
// next-in-flow is the last next-in-flow for aChild AND the
// next-in-flow is not the last child in parent)
NS_ASSERTION(aChild->GetGeometricParent() == parent, "screwy flow");
NS_ASSERTION(aChild->GetNextSibling() == nextInFlow, "unexpected sibling");
NS_ASSERTION(parent->IsChild(aChild), "screwy flow");
aChild->GetNextSibling(nextSibling);
NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");
aChild->SetNextSibling(nextInFlow->GetNextSibling());
nextInFlow->GetNextSibling(nextSibling);
aChild->SetNextSibling(nextSibling);
}
// Delete the next-in-flow frame and adjust it's parent's child count
nextInFlow->DeleteFrame();
parent->mChildCount--;
NS_POSTCONDITION(nsnull == aChild->GetNextInFlow(), "non null next-in-flow");
#ifdef NS_DEBUG
aChild->GetNextInFlow(nextInFlow);
NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
#endif
return PR_TRUE;
}
@ -1268,10 +1344,13 @@ void nsTableOuterFrame::CreateInnerTableFrame(nsIPresContext* aPresContext)
nsIFrame* prevInnerTable = prevOuterTable->mInnerTableFrame;
// Create a continuing column
mInnerTableFrame = (nsTableFrame *)prevInnerTable->GetNextInFlow();
prevInnerTable->GetNextInFlow((nsIFrame*&)mInnerTableFrame);
if (nsnull==mInnerTableFrame)
{
mInnerTableFrame = (nsTableFrame *)prevInnerTable->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
prevInnerTable->CreateContinuingFrame(aPresContext, this, continuingFrame);
mInnerTableFrame = (nsTableFrame*)continuingFrame;
mChildCount++;
}
}

31
layout/tables/nsTableOuterFrame.h
Просмотреть файл

@ -56,9 +56,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** outer tables are reflowed in two steps.
* Step 1:, we lay out all of the captions and the inner table with
@ -85,20 +85,23 @@ public:
* @see nsTableFrame::BalanceColumnWidths
* @see nsIFrame::ResizeReflow
*/
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
/** destructor */
virtual ~nsTableOuterFrame();
@ -205,7 +208,7 @@ protected:
/** overridden here to handle special caption-table relationship
* @see nsContainerFrame::VerifyTree
*/
virtual void VerifyTree() const;
NS_IMETHOD VerifyTree() const;
/** overridden here to handle special caption-table relationship
* @see nsContainerFrame::PrepareContinuingFrame

87
layout/tables/nsTableRowFrame.cpp
Просмотреть файл

@ -63,9 +63,9 @@ void nsTableRowFrame::SetMaxChildHeight(PRInt32 aChildHeight)
mTallestCell = aChildHeight;
}
void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableRowFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// for debug...
if (nsIFrame::GetShowFrameBorders()) {
@ -74,6 +74,7 @@ void nsTableRowFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
// aDirtyRect is in our coordinate system
@ -87,7 +88,9 @@ void nsTableRowFrame::PaintChildren(nsIPresContext& aPresContext,
{
nsIFrame* kid = mFirstChild;
while (nsnull != kid) {
nsIView *pView = kid->GetView();
nsIView *pView;
kid->GetView(pView);
if (nsnull == pView) {
nsRect kidRect;
kid->GetRect(kidRect);
@ -103,10 +106,10 @@ void nsTableRowFrame::PaintChildren(nsIPresContext& aPresContext,
aRenderingContext.DrawRect(0, 0, kidRect.width, kidRect.height);
}
aRenderingContext.PopState();
}
else
} else {
NS_RELEASE(pView);
kid = kid->GetNextSibling();
}
kid->GetNextSibling(kid);
}
}
@ -129,11 +132,12 @@ are present.
* This method stacks rows horizontally according to HTML 4.0 rules.
* Rows are responsible for layout of their children.
*/
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE)
printf("nsTableRowFrame::ResizeReflow - %p with aMaxSize = %d, %d\n",
@ -145,7 +149,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
PRInt32 maxCellHeight = 0;
ResetMaxChildHeight();
ReflowStatus result = frComplete;
aStatus = frComplete;
mFirstContentOffset = mLastContentOffset = 0;
@ -165,17 +169,21 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
// Row doesn't factor in insets, the cells do that
nsTableFrame *tableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
nsTableFrame *tableFrame;
mContentParent->GetContentParent((nsIFrame*&)tableFrame);
for (;;) {
nsIContent* kid = c->ChildAt(kidIndex); // kid: REFCNT++
if (nsnull == kid) {
result = frComplete;
aStatus = frComplete;
break;
}
// get frame, creating one if needed
nsIFrame* kidFrame = ChildAt(kidIndex);
nsIFrame* kidFrame;
ChildAt(kidIndex, kidFrame);
if (nsnull==kidFrame)
{
nsIContentDelegate* kidDel;
@ -191,20 +199,24 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
NS_RELEASE(kidStyleContext);
}
nsTableCell* cell = (nsTableCell *)(kidFrame->GetContent()); // cell: ADDREF++
nsTableCell* cell;
kidFrame->GetContent((nsIContent*&)cell); // cell: ADDREF++
// Try to reflow the child into the available space.
if (NS_UNCONSTRAINEDSIZE == availSize.width)
{ // Each cell is given the entire row width to try to lay out into
result = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSize, &kidMaxSize);
if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
result==frComplete?"complete":"NOT complete",
aStatus==frComplete?"complete":"NOT complete",
kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
nsCellLayoutData kidLayoutData((nsTableCellFrame *)kidFrame, &kidSize, &kidMaxSize);
tableFrame->SetCellLayoutData(&kidLayoutData, cell);
}
else
{ // we're in a constrained situation, so get the avail width from the known column widths
nsTableFrame *innerTableFrame = (nsTableFrame *)(GetContentParent()->GetContentParent());
nsTableFrame *innerTableFrame;
mContentParent->GetContentParent((nsIFrame*&)innerTableFrame);
nsCellLayoutData *cellData = innerTableFrame->GetCellLayoutData(cell);
PRInt32 cellStartingCol = cell->GetColIndex();
PRInt32 cellColSpan = cell->GetColSpan();
@ -213,9 +225,9 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
availWidth += innerTableFrame->GetColumnWidth(cellStartingCol+numColSpan);
NS_ASSERTION(0<availWidth, "illegal width for this column");
nsSize availSizeWithSpans(availWidth, availSize.height);
result = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
aStatus = ReflowChild(kidFrame, aPresContext, kidSize, availSizeWithSpans, &kidMaxSize);
if (gsDebug1) printf("reflow of cell returned result = %s with desired=%d,%d, min = %d,%d\n",
result==frComplete?"complete":"NOT complete",
aStatus==frComplete?"complete":"NOT complete",
kidSize.width, kidSize.height, kidMaxSize.width, kidMaxSize.height);
// SEC: TODO: this next block could be smarter,
@ -268,7 +280,7 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
prevKidFrame = kidFrame;
kidIndex++;
if (frNotComplete == result) {
if (frNotComplete == aStatus) {
// If the child didn't finish layout then it means that it used
// up all of our available space (or needs us to split).
mLastContentIsComplete = PR_FALSE;
@ -278,12 +290,11 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
}
if (nsnull != prevKidFrame) {
if (LastChild()!=prevKidFrame)
if (!IsLastChild(prevKidFrame))
{
nsIFrame * frame = LastChild();
GetGeometricParent()->List();
mGeometricParent->List();
}
NS_ASSERTION(LastChild() == prevKidFrame, "unexpected last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
SetLastContentOffset(prevKidFrame);
}
@ -298,46 +309,48 @@ nsTableRowFrame::ResizeReflow(nsIPresContext* aPresContext,
SetMaxChildHeight(maxCellHeight); // remember height of tallest child who doesn't have a row span
#ifdef NS_DEBUG
PostReflowCheck(result);
PostReflowCheck(aStatus);
#endif
if (gsDebug1==PR_TRUE)
{
if (nsnull!=aMaxElementSize)
printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
result==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height,
aMaxElementSize->width, aMaxElementSize->height);
else
printf("nsTableRowFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n",
result==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height);
}
// testing...
result = frComplete;
return result;
aStatus = frComplete;
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::IncrementalReflow\n");
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame* nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableRowFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
if (gsDebug1==PR_TRUE) printf("nsTableRowFrame::CreateContinuingFrame\n");
nsTableRowFrame* cf = new nsTableRowFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
nsresult nsTableRowFrame::NewFrame( nsIFrame** aInstancePtrResult,

29
layout/tables/nsTableRowFrame.h
Просмотреть файл

@ -52,9 +52,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** ask all children to paint themselves, without clipping (for cells with rowspan>1)
@ -77,20 +77,23 @@ public:
* @see nsTableFrame::BalanceColumnWidths
* @see nsTableFrame::ShrinkWrapChildren
*/
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame::CreateContinuingFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
/** set mTallestCell to 0 in anticipation of recalculating it */
void ResetMaxChildHeight();

138
layout/tables/nsTableRowGroupFrame.cpp
Просмотреть файл

@ -102,9 +102,9 @@ nsTableRowGroupFrame::~nsTableRowGroupFrame()
}
void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
NS_METHOD nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// for debug...
@ -114,6 +114,7 @@ void nsTableRowGroupFrame::Paint(nsIPresContext& aPresContext,
}
PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
return NS_OK;
}
// aDirtyRect is in our coordinate system
@ -127,7 +128,9 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext& aPresContext,
{
nsIFrame* kid = mFirstChild;
while (nsnull != kid) {
nsIView *pView = kid->GetView();
nsIView *pView;
kid->GetView(pView);
if (nsnull == pView) {
nsRect kidRect;
kid->GetRect(kidRect);
@ -146,7 +149,7 @@ void nsTableRowGroupFrame::PaintChildren(nsIPresContext& aPresContext,
}
else
NS_RELEASE(pView);
kid = kid->GetNextSibling();
kid->GetNextSibling(kid);
}
}
@ -257,8 +260,12 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
nsIFrame::ReflowStatus status;
// Get top margin for this kid
nsIContent* kid = kidFrame->GetContent();
nsIStyleContext* kidSC = kidFrame->GetStyleContext(aPresContext);
nsIContent* kid;
kidFrame->GetContent(kid);
nsIStyleContext* kidSC;
kidFrame->GetStyleContext(aPresContext, kidSC);
nsStyleMolecule* kidMol = (nsStyleMolecule*)kidSC->GetData(kStyleMoleculeSID);
nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMol);
nscoord bottomMargin = kidMol->margin.bottom;
@ -331,16 +338,21 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
if (frNotComplete == status) {
// XXX It's good to assume that we might still have room
// even if the child didn't complete (floaters will want this)
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
PRBool lastContentIsComplete = mLastContentIsComplete;
if (nsnull == kidNextInFlow) {
// No the child isn't complete, and it doesn't have a next in flow so
// create a continuing frame. This hooks the child into the flow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
// Insert the frame. We'll reflow it next pass through the loop
nsIFrame* nextSib = kidFrame->GetNextSibling();
nsIFrame* nextSib;
kidFrame->GetNextSibling(nextSib);
continuingFrame->SetNextSibling(nextSib);
kidFrame->SetNextSibling(continuingFrame);
if (nsnull == nextSib) {
@ -352,7 +364,9 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
}
// We've used up all of our available space so push the remaining
// children to the next-in-flow
nsIFrame* nextSibling = kidFrame->GetNextSibling();
nsIFrame* nextSibling;
kidFrame->GetNextSibling(nextSibling);
if (nsnull != nextSibling) {
PushChildren(nextSibling, kidFrame, lastContentIsComplete);
SetLastContentOffset(prevKidFrame);
@ -362,15 +376,23 @@ PRBool nsTableRowGroupFrame::ReflowMappedChildren( nsIPresContext* aPresCon
}
// Get the next child
kidFrame = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(kidFrame);
}
// Update the child count
mChildCount = childCount;
#ifdef NS_DEBUG
NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");
NS_POSTCONDITION(LastChild()->GetIndexInParent() == mLastContentOffset, "bad last content offset");
nsIFrame* lastChild;
PRInt32 lastIndexInParent;
LastChild(lastChild);
lastChild->GetIndexInParent(lastIndexInParent);
NS_POSTCONDITION(lastIndexInParent == mLastContentOffset, "bad last content offset");
#endif
#ifdef NS_DEBUG
VerifyLastIsComplete();
@ -436,7 +458,9 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
#ifdef NS_DEBUG
PRInt32 kidIndex = NextChildOffset();
#endif
nsIFrame* prevKidFrame = LastChild();
nsIFrame* prevKidFrame;
LastChild(prevKidFrame);
// This will hold the prevKidFrame's mLastContentIsComplete
// status. If we have to push the frame that follows prevKidFrame
@ -465,7 +489,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
kidFrame = nextInFlow->mFirstChild;
} else {
// We've pulled up all the children, so move to the next-in-flow.
nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
continue;
}
}
@ -473,8 +497,12 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// See if the child fits in the available space. If it fits or
// it's splittable then reflow it. The reason we can't just move
// it is that we still need ascent/descent information
if ((kidFrame->GetHeight() > aState.availSize.height) &&
!kidFrame->IsSplittable()) {
nsSize kidFrameSize;
PRBool kidIsSplittable;
kidFrame->GetSize(kidFrameSize);
kidFrame->IsSplittable(kidIsSplittable);
if ((kidFrameSize.height > aState.availSize.height) && !kidIsSplittable) {
result = PR_FALSE;
mLastContentIsComplete = prevLastContentIsComplete;
break;
@ -499,7 +527,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
PlaceChild(aPresContext, aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);
// Remove the frame from its current parent
nextInFlow->mFirstChild = kidFrame->GetNextSibling();
kidFrame->GetNextSibling(nextInFlow->mFirstChild);
nextInFlow->mChildCount--;
// Update the next-in-flows first content offset
if (nsnull != nextInFlow->mFirstChild) {
@ -508,7 +536,10 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// Link the frame into our list of children
kidFrame->SetGeometricParent(this);
if (nextInFlow == kidFrame->GetContentParent()) {
nsIFrame* kidContentParent;
kidFrame->GetContentParent(kidContentParent);
if (nextInFlow == kidContentParent) {
kidFrame->SetContentParent(this);
}
if (nsnull == prevKidFrame) {
@ -528,13 +559,16 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
mLastContentIsComplete = PRBool(status == frComplete);
if (frNotComplete == status) {
// No the child isn't complete
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
nsIFrame* kidNextInFlow;
kidFrame->GetNextInFlow(kidNextInFlow);
if (nsnull == kidNextInFlow) {
// The child doesn't have a next-in-flow so create a
// continuing frame. The creation appends it to the flow and
// prepares it for reflow.
nsIFrame* continuingFrame =
kidFrame->CreateContinuingFrame(aPresContext, this);
nsIFrame* continuingFrame;
kidFrame->CreateContinuingFrame(aPresContext, this, continuingFrame);
NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");
// Add the continuing frame to our sibling list and then push
@ -562,7 +596,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// Update our last content offset
if (nsnull != prevKidFrame) {
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
}
@ -582,7 +616,7 @@ PRBool nsTableRowGroupFrame::PullUpChildren(nsIPresContext* aPresContext,
// the next-in-flows must be empty. Do a sanity check
while (nsnull != nextInFlow) {
NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
nextInFlow = (nsTableRowGroupFrame*)nextInFlow->GetNextInFlow();
nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
}
#endif
}
@ -643,7 +677,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
mFirstContentOffset = prev->NextChildOffset();
if (!prev->mLastContentIsComplete) {
// Our prev-in-flow's last child is not complete
kidPrevInFlow = prev->LastChild();
prev->LastChild(kidPrevInFlow);
}
}
@ -653,7 +687,9 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
nsSize kidMaxElementSize;
nsSize* pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
PRInt32 kidIndex = NextChildOffset();
nsIFrame* prevKidFrame = LastChild(); // XXX remember this...
nsIFrame* prevKidFrame;
LastChild(prevKidFrame); // XXX remember this...
for (;;) {
// Get the next content object
@ -688,7 +724,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
NS_RELEASE(kidDel);
kidFrame->SetStyleContext(kidStyleContext);
} else {
kidFrame = kidPrevInFlow->CreateContinuingFrame(aPresContext, this);
kidPrevInFlow->CreateContinuingFrame(aPresContext, this, kidFrame);
}
NS_RELEASE(kid);
NS_RELEASE(kidStyleContext);
@ -738,7 +774,7 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
}
// Update the content mapping
NS_ASSERTION(LastChild() == prevKidFrame, "bad last child");
NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
SetLastContentOffset(prevKidFrame);
#ifdef NS_DEBUG
PRInt32 len = LengthOf(mFirstChild);
@ -755,11 +791,12 @@ nsTableRowGroupFrame::ReflowUnmappedChildren(nsIPresContext* aPresContext,
* This method stacks rows vertically according to HTML 4.0 rules.
* Rows are responsible for layout of their children.
*/
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize)
nsSize* aMaxElementSize,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE)
printf("nsTableRowGroupFrame::ResizeReflow - aMaxSize = %d, %d\n",
@ -774,8 +811,9 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
aMaxElementSize->height = 0;
}
PRBool reflowMappedOK = PR_TRUE;
ReflowStatus status = frComplete;
PRBool reflowMappedOK = PR_TRUE;
aStatus = frComplete;
// Check for an overflow list
MoveOverflowToChildList();
@ -788,7 +826,7 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
if (nsnull != mFirstChild) {
reflowMappedOK = ReflowMappedChildren(aPresContext, state, aMaxElementSize);
if (PR_FALSE == reflowMappedOK) {
status = frNotComplete;
aStatus = frNotComplete;
}
}
@ -798,24 +836,24 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
if (state.availSize.height <= 0) {
// No space left. Don't try to pull-up children or reflow unmapped
if (NextChildOffset() < mContent->ChildCount()) {
status = frNotComplete;
aStatus = frNotComplete;
}
} else if (NextChildOffset() < mContent->ChildCount()) {
// Try and pull-up some children from a next-in-flow
if (PullUpChildren(aPresContext, state, aMaxElementSize)) {
// If we still have unmapped children then create some new frames
if (NextChildOffset() < mContent->ChildCount()) {
status = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
aStatus = ReflowUnmappedChildren(aPresContext, state, aMaxElementSize);
}
} else {
// We were unable to pull-up all the existing frames from the
// next in flow
status = frNotComplete;
aStatus = frNotComplete;
}
}
}
if (frComplete == status) {
if (frComplete == aStatus) {
// Don't forget to add in the bottom margin from our last child.
// Only add it in if there's room for it.
nscoord margin = state.prevMaxPosBottomMargin -
@ -832,31 +870,32 @@ nsTableRowGroupFrame::ResizeReflow( nsIPresContext* aPresContext,
aDesiredSize.height = state.y;
#ifdef NS_DEBUG
PostReflowCheck(status);
PostReflowCheck(aStatus);
#endif
if (gsDebug1==PR_TRUE)
{
if (nsnull!=aMaxElementSize)
printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=%d,%d\n",
status==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height,
aMaxElementSize->width, aMaxElementSize->height);
else
printf("nsTableRowGroupFrame::RR returning: %s with aDesiredSize=%d,%d, aMES=NSNULL\n",
status==frComplete?"Complete":"Not Complete",
aStatus==frComplete?"Complete":"Not Complete",
aDesiredSize.width, aDesiredSize.height);
}
return status;
return NS_OK;
}
nsIFrame::ReflowStatus
NS_METHOD
nsTableRowGroupFrame::IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand)
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus)
{
if (gsDebug1==PR_TRUE) printf("nsTableRowGroupFrame::IncrementalReflow\n");
@ -864,16 +903,19 @@ nsTableRowGroupFrame::IncrementalReflow(nsIPresContext* aPresContext,
aDesiredSize.width = aMaxSize.width;
aDesiredSize.height = aMaxSize.height;
return frComplete;
aStatus = frComplete;
return NS_OK;
}
nsIFrame* nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent)
NS_METHOD nsTableRowGroupFrame::CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame)
{
nsTableRowGroupFrame* cf = new nsTableRowGroupFrame(mContent, mIndexInParent, aParent);
PrepareContinuingFrame(aPresContext, aParent, cf);
if (PR_TRUE==gsDebug1) printf("nsTableRowGroupFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
return cf;
aContinuingFrame = cf;
return NS_OK;
}
/* ----- static methods ----- */

29
layout/tables/nsTableRowGroupFrame.h
Просмотреть файл

@ -53,9 +53,9 @@ public:
nsIFrame* aParent);
/** @see nsIFrame::Paint */
virtual void Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
NS_IMETHOD Paint(nsIPresContext& aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect);
/** ask all children to paint themselves, without clipping (for cells with rowspan>1)
* @see nsIFrame::Paint
@ -73,19 +73,22 @@ public:
*
* @see nsIFrame::ResizeReflow
*/
ReflowStatus ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize);
NS_IMETHOD ResizeReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsSize* aMaxElementSize,
ReflowStatus& aStatus);
/** @see nsIFrame::IncrementalReflow */
ReflowStatus IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand);
NS_IMETHOD IncrementalReflow(nsIPresContext* aPresContext,
nsReflowMetrics& aDesiredSize,
const nsSize& aMaxSize,
nsReflowCommand& aReflowCommand,
ReflowStatus& aStatus);
/** @see nsContainerFrame::CreateContinuingFrame */
virtual nsIFrame* CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent);
NS_IMETHOD CreateContinuingFrame(nsIPresContext* aPresContext,
nsIFrame* aParent,
nsIFrame*& aContinuingFrame);
protected:

2
view/src/nsView.cpp
Просмотреть файл

@ -365,7 +365,7 @@ nsEventStatus nsView :: HandleEvent(nsGUIEvent *event, PRBool aCheckParent, PRBo
event->point.x += xoff;
event->point.y += yoff;
retval = mFrame->HandleEvent(*cx, event);
mFrame->HandleEvent(*cx, event, retval);
event->point.x -= xoff;
event->point.y -= yoff;