1998-04-14 00:24:54 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
|
|
* http://www.mozilla.org/NPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* NPL.
|
|
|
|
*
|
|
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
|
|
* Communications Corporation. Portions created by Netscape are
|
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
|
|
* Reserved.
|
|
|
|
*/
|
|
|
|
#include "nsTableOuterFrame.h"
|
|
|
|
#include "nsTableFrame.h"
|
1998-06-09 08:51:44 +04:00
|
|
|
#include "nsIReflowCommand.h"
|
1998-04-14 00:24:54 +04:00
|
|
|
#include "nsIStyleContext.h"
|
|
|
|
#include "nsStyleConsts.h"
|
|
|
|
#include "nsIPresContext.h"
|
|
|
|
#include "nsIRenderingContext.h"
|
|
|
|
#include "nsCSSRendering.h"
|
|
|
|
#include "nsIContent.h"
|
|
|
|
#include "nsVoidArray.h"
|
1998-04-22 10:37:57 +04:00
|
|
|
#include "nsIPtr.h"
|
1998-07-02 21:40:56 +04:00
|
|
|
#include "prinrval.h"
|
1998-10-01 08:46:11 +04:00
|
|
|
#include "nsHTMLIIDs.h"
|
1999-02-24 08:54:31 +03:00
|
|
|
#include "nsLayoutAtoms.h"
|
1999-08-10 07:52:15 +04:00
|
|
|
#include "nsHTMLParts.h"
|
|
|
|
#include "nsIPresShell.h"
|
1998-04-14 00:24:54 +04:00
|
|
|
|
|
|
|
struct OuterTableReflowState {
|
|
|
|
|
1998-04-17 02:21:32 +04:00
|
|
|
// The presentation context
|
|
|
|
nsIPresContext *pc;
|
|
|
|
|
1998-05-30 00:36:05 +04:00
|
|
|
// Our reflow state
|
1998-10-02 08:10:00 +04:00
|
|
|
const nsHTMLReflowState& reflowState;
|
1998-05-30 00:36:05 +04:00
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
// The total available size (computed from the parent)
|
|
|
|
nsSize availSize;
|
|
|
|
// The available size for the inner table frame
|
|
|
|
nsSize innerTableMaxSize;
|
|
|
|
|
|
|
|
// Margin tracking information
|
|
|
|
nscoord prevMaxPosBottomMargin;
|
|
|
|
nscoord prevMaxNegBottomMargin;
|
|
|
|
|
|
|
|
// Flags for whether the max size is unconstrained
|
|
|
|
PRBool unconstrainedWidth;
|
|
|
|
PRBool unconstrainedHeight;
|
|
|
|
|
|
|
|
// Running y-offset
|
|
|
|
nscoord y;
|
|
|
|
|
1998-10-08 19:34:48 +04:00
|
|
|
OuterTableReflowState(nsIPresContext& aPresContext,
|
1998-10-02 08:10:00 +04:00
|
|
|
const nsHTMLReflowState& aReflowState)
|
1998-05-30 00:36:05 +04:00
|
|
|
: reflowState(aReflowState)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
1998-10-08 19:34:48 +04:00
|
|
|
pc = &aPresContext;
|
1999-01-06 02:31:18 +03:00
|
|
|
availSize.width = reflowState.availableWidth;
|
|
|
|
availSize.height = reflowState.availableHeight;
|
1998-04-14 00:24:54 +04:00
|
|
|
prevMaxPosBottomMargin = 0;
|
|
|
|
prevMaxNegBottomMargin = 0;
|
|
|
|
y=0; // border/padding/margin???
|
1999-01-06 02:31:18 +03:00
|
|
|
unconstrainedWidth = PRBool(aReflowState.availableWidth == NS_UNCONSTRAINEDSIZE);
|
|
|
|
unconstrainedHeight = PRBool(aReflowState.availableHeight == NS_UNCONSTRAINEDSIZE);
|
1998-06-03 04:43:53 +04:00
|
|
|
innerTableMaxSize.width=0;
|
|
|
|
innerTableMaxSize.height=0;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
~OuterTableReflowState() {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* ----------- nsTableOuterFrame ---------- */
|
|
|
|
|
1999-08-01 22:26:45 +04:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsTableOuterFrame, nsHTMLContainerFrame)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsTableOuterFrame, nsHTMLContainerFrame)
|
|
|
|
|
|
|
|
nsresult nsTableOuterFrame::QueryInterface(const nsIID& aIID, void** aInstancePtr)
|
|
|
|
{
|
|
|
|
if (NULL == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
if (aIID.Equals(nsITableLayout::GetIID()))
|
|
|
|
{ // note there is no addref here, frames are not addref'd
|
|
|
|
*aInstancePtr = (void*)(nsITableLayout*)this;
|
|
|
|
return NS_OK;
|
|
|
|
} else {
|
|
|
|
return nsHTMLContainerFrame::QueryInterface(aIID, aInstancePtr);
|
|
|
|
}
|
|
|
|
}
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1998-11-10 09:05:32 +03:00
|
|
|
NS_IMETHODIMP nsTableOuterFrame::SetInitialChildList(nsIPresContext& aPresContext,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aChildList)
|
1998-09-16 21:19:20 +04:00
|
|
|
{
|
1999-01-16 01:52:05 +03:00
|
|
|
mFrames.SetFrames(aChildList);
|
1998-09-16 21:19:20 +04:00
|
|
|
|
|
|
|
// Set our internal member data
|
1999-01-16 01:52:05 +03:00
|
|
|
mInnerTableFrame = aChildList;
|
1998-10-22 02:29:00 +04:00
|
|
|
//XXX this should go through the child list looking for a displaytype==caption
|
1999-01-20 10:27:06 +03:00
|
|
|
if (1 < mFrames.GetLength()) {
|
|
|
|
nsIFrame *child;
|
1999-02-10 09:13:38 +03:00
|
|
|
nsresult result = aChildList->GetNextSibling(&child);
|
1999-04-04 04:06:48 +04:00
|
|
|
while ((NS_SUCCEEDED(result)) && (nsnull!=child)) {
|
1999-01-20 10:27:06 +03:00
|
|
|
const nsStyleDisplay* childDisplay;
|
|
|
|
child->GetStyleData(eStyleStruct_Display, (const nsStyleStruct *&)childDisplay);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (NS_STYLE_DISPLAY_TABLE_CAPTION==childDisplay->mDisplay) {
|
1999-01-20 10:27:06 +03:00
|
|
|
mCaptionFrame = child;
|
|
|
|
break;
|
|
|
|
}
|
1999-02-10 09:13:38 +03:00
|
|
|
result = child->GetNextSibling(&child);
|
1999-01-20 10:27:06 +03:00
|
|
|
}
|
1998-09-16 21:19:20 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-08-10 07:52:15 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsTableOuterFrame::AppendFrames(nsIPresContext& aPresContext,
|
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
|
|
|
const nsStyleDisplay* display;
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
// We only have two child frames: the inner table and one caption frame.
|
|
|
|
// The inner frame is provided when we're initialized, and it cannot change
|
|
|
|
aFrameList->GetStyleData(eStyleStruct_Display, ((const nsStyleStruct *&)display));
|
|
|
|
if (NS_STYLE_DISPLAY_TABLE_CAPTION == display->mDisplay) {
|
|
|
|
NS_PRECONDITION(!mCaptionFrame, "already have a caption frame");
|
|
|
|
// We only support having a single caption frame
|
|
|
|
if (mCaptionFrame || (LengthOf(aFrameList) > 1)) {
|
|
|
|
rv = NS_ERROR_UNEXPECTED;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
// Insert the caption frame into the child list
|
|
|
|
mCaptionFrame = aFrameList;
|
|
|
|
mInnerTableFrame->SetNextSibling(aFrameList);
|
|
|
|
|
|
|
|
// Reflow the new caption frame. It's already marked dirty, so generate a reflow
|
|
|
|
// command that tells us to reflow our dirty child frames
|
|
|
|
nsIReflowCommand* reflowCmd;
|
|
|
|
|
|
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, this, nsIReflowCommand::ReflowDirty);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
aPresShell.AppendReflowCommand(reflowCmd);
|
|
|
|
NS_RELEASE(reflowCmd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
NS_PRECONDITION(PR_FALSE, "unexpected child frame type");
|
|
|
|
rv = NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsTableOuterFrame::InsertFrames(nsIPresContext& aPresContext,
|
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aPrevFrame,
|
|
|
|
nsIFrame* aFrameList)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(!aPrevFrame, "invalid previous frame");
|
|
|
|
return AppendFrames(aPresContext, aPresShell, aListName, aFrameList);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsTableOuterFrame::RemoveFrame(nsIPresContext& aPresContext,
|
|
|
|
nsIPresShell& aPresShell,
|
|
|
|
nsIAtom* aListName,
|
|
|
|
nsIFrame* aOldFrame)
|
|
|
|
{
|
|
|
|
const nsStyleDisplay* display;
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
// We only have two child frames: the inner table and one caption frame.
|
|
|
|
// The inner frame can't be removed so this should be the caption
|
|
|
|
aOldFrame->GetStyleData(eStyleStruct_Display, ((const nsStyleStruct *&)display));
|
|
|
|
NS_PRECONDITION(NS_STYLE_DISPLAY_TABLE_CAPTION == display->mDisplay,
|
|
|
|
"can't remove inner frame");
|
|
|
|
|
|
|
|
// See if the caption's minimum width impacted the inner table
|
|
|
|
if (mMinCaptionWidth > mRect.width) {
|
|
|
|
// The old caption width had an effect on the inner table width so
|
|
|
|
// we're going to need to reflow it. Mark it dirty
|
|
|
|
nsFrameState frameState;
|
|
|
|
mInnerTableFrame->GetFrameState(&frameState);
|
|
|
|
frameState |= NS_FRAME_IS_DIRTY;
|
|
|
|
mInnerTableFrame->SetFrameState(frameState);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the caption frame from the child list and destroy it
|
|
|
|
mFrames.DestroyFrame(aPresContext, aOldFrame);
|
|
|
|
mCaptionFrame = nsnull;
|
|
|
|
mMinCaptionWidth = 0;
|
|
|
|
|
|
|
|
// Generate a reflow command so we get reflowed
|
|
|
|
nsIReflowCommand* reflowCmd;
|
|
|
|
|
|
|
|
rv = NS_NewHTMLReflowCommand(&reflowCmd, this, nsIReflowCommand::ReflowDirty);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
aPresShell.AppendReflowCommand(reflowCmd);
|
|
|
|
NS_RELEASE(reflowCmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-04-04 04:06:48 +04:00
|
|
|
NS_METHOD nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
|
1998-04-17 05:41:24 +04:00
|
|
|
nsIRenderingContext& aRenderingContext,
|
1999-04-04 04:06:48 +04:00
|
|
|
const nsRect& aDirtyRect,
|
|
|
|
nsFramePaintLayer aWhichLayer)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
|
|
|
// for debug...
|
1999-03-26 03:39:35 +03:00
|
|
|
if ((NS_FRAME_PAINT_LAYER_DEBUG == aWhichLayer) && GetShowFrameBorders()) {
|
1998-04-14 00:24:54 +04:00
|
|
|
aRenderingContext.SetColor(NS_RGB(255,0,0));
|
|
|
|
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
|
|
|
|
}
|
|
|
|
|
1998-12-18 18:54:23 +03:00
|
|
|
PaintChildren(aPresContext, aRenderingContext, aDirtyRect, aWhichLayer);
|
1998-04-17 05:41:24 +04:00
|
|
|
return NS_OK;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
|
|
|
|
1999-05-20 04:52:00 +04:00
|
|
|
NS_IMETHODIMP nsTableOuterFrame::SetSelected(nsIDOMRange *aRange,PRBool aSelected, nsSpread aSpread)
|
|
|
|
{
|
|
|
|
nsresult result = nsFrame::SetSelected(aRange,aSelected, aSpread);
|
|
|
|
if (NS_SUCCEEDED(result) && mInnerTableFrame)
|
|
|
|
return mInnerTableFrame->SetSelected(aRange,aSelected, aSpread);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-08-19 07:51:25 +04:00
|
|
|
PRBool nsTableOuterFrame::NeedsReflow(const nsHTMLReflowState& aReflowState)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
|
|
|
PRBool result=PR_TRUE;
|
1999-04-04 04:06:48 +04:00
|
|
|
if (nsnull != mInnerTableFrame) {
|
1999-08-19 07:51:25 +04:00
|
|
|
result = ((nsTableFrame *)mInnerTableFrame)->NeedsReflow(aReflowState);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-04-14 00:24:54 +04:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1998-06-19 04:34:12 +04:00
|
|
|
// Recover the reflow state to what it should be if aKidFrame is about
|
|
|
|
// to be reflowed
|
1998-10-08 19:34:48 +04:00
|
|
|
nsresult nsTableOuterFrame::RecoverState(OuterTableReflowState& aReflowState,
|
1998-06-19 04:34:12 +04:00
|
|
|
nsIFrame* aKidFrame)
|
|
|
|
{
|
1998-10-08 19:34:48 +04:00
|
|
|
#if 0
|
1998-06-22 09:34:17 +04:00
|
|
|
// Get aKidFrame's previous sibling
|
1998-06-19 04:34:12 +04:00
|
|
|
nsIFrame* prevKidFrame = nsnull;
|
1999-01-16 01:52:05 +03:00
|
|
|
for (nsIFrame* frame = mFrames.FirstChild(); frame != aKidFrame;) {
|
1998-06-19 04:34:12 +04:00
|
|
|
prevKidFrame = frame;
|
|
|
|
frame->GetNextSibling(frame);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nsnull != prevKidFrame) {
|
|
|
|
nsRect rect;
|
|
|
|
|
|
|
|
// Set our running y-offset
|
|
|
|
prevKidFrame->GetRect(rect);
|
1998-10-08 19:34:48 +04:00
|
|
|
aReflowState.y = rect.YMost();
|
1998-06-19 04:34:12 +04:00
|
|
|
|
|
|
|
// Adjust the available space
|
1998-10-08 19:34:48 +04:00
|
|
|
if (PR_FALSE == aReflowState.unconstrainedHeight) {
|
|
|
|
aReflowState.availSize.height -= aReflowState.y;
|
1998-06-19 04:34:12 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Get the previous frame's bottom margin
|
|
|
|
const nsStyleSpacing* kidSpacing;
|
1998-12-02 19:45:20 +03:00
|
|
|
prevKidFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)kidSpacing);
|
1998-06-19 04:34:12 +04:00
|
|
|
nsMargin margin;
|
|
|
|
kidSpacing->CalcMarginFor(prevKidFrame, margin);
|
|
|
|
if (margin.bottom < 0) {
|
1998-10-08 19:34:48 +04:00
|
|
|
aReflowState.prevMaxNegBottomMargin = -margin.bottom;
|
1998-06-19 04:34:12 +04:00
|
|
|
} else {
|
1998-10-08 19:34:48 +04:00
|
|
|
aReflowState.prevMaxPosBottomMargin = margin.bottom;
|
1998-06-19 04:34:12 +04:00
|
|
|
}
|
|
|
|
}
|
1998-10-08 19:34:48 +04:00
|
|
|
#endif
|
|
|
|
|
1999-04-04 04:06:48 +04:00
|
|
|
aReflowState.y = 0;
|
1998-06-19 04:34:12 +04:00
|
|
|
|
|
|
|
// Set the inner table max size
|
|
|
|
nsSize innerTableSize(0,0);
|
|
|
|
|
|
|
|
mInnerTableFrame->GetSize(innerTableSize);
|
1998-10-08 19:34:48 +04:00
|
|
|
aReflowState.innerTableMaxSize.width = innerTableSize.width;
|
1999-01-06 02:31:18 +03:00
|
|
|
aReflowState.innerTableMaxSize.height = aReflowState.reflowState.availableHeight;
|
1998-06-19 04:34:12 +04:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-10-08 19:34:48 +04:00
|
|
|
nsresult nsTableOuterFrame::IncrementalReflow(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
1998-06-19 04:34:12 +04:00
|
|
|
{
|
1998-10-01 08:46:11 +04:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
1998-10-08 19:34:48 +04:00
|
|
|
// determine if this frame is the target or not
|
1999-04-04 04:06:48 +04:00
|
|
|
nsIFrame* target=nsnull;
|
1998-10-08 19:34:48 +04:00
|
|
|
rv = aReflowState.reflowState.reflowCommand->GetTarget(target);
|
1999-04-04 04:06:48 +04:00
|
|
|
if ((PR_TRUE == NS_SUCCEEDED(rv)) && (nsnull != target)) {
|
|
|
|
if (this == target) {
|
1998-10-08 19:34:48 +04:00
|
|
|
rv = IR_TargetIsMe(aPresContext, aDesiredSize, aReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-10-08 19:34:48 +04:00
|
|
|
// Get the next frame in the reflow chain
|
|
|
|
nsIFrame* nextFrame;
|
|
|
|
aReflowState.reflowState.reflowCommand->GetNext(nextFrame);
|
|
|
|
|
|
|
|
// Recover our reflow state
|
|
|
|
RecoverState(aReflowState, nextFrame);
|
|
|
|
rv = IR_TargetIsChild(aPresContext, aDesiredSize, aReflowState, aStatus, nextFrame);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
1998-06-19 04:34:12 +04:00
|
|
|
|
1998-10-08 19:34:48 +04:00
|
|
|
nsresult nsTableOuterFrame::IR_TargetIsChild(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus,
|
1999-04-04 04:06:48 +04:00
|
|
|
nsIFrame* aNextFrame)
|
1998-10-08 19:34:48 +04:00
|
|
|
{
|
|
|
|
nsresult rv;
|
1999-07-02 09:28:32 +04:00
|
|
|
if (!aNextFrame)
|
|
|
|
return NS_OK;
|
|
|
|
|
1999-04-04 04:06:48 +04:00
|
|
|
if (aNextFrame == mInnerTableFrame) {
|
1998-10-08 19:34:48 +04:00
|
|
|
rv = IR_TargetIsInnerTableFrame(aPresContext, aDesiredSize, aReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
else if (aNextFrame==mCaptionFrame) {
|
1998-10-08 19:34:48 +04:00
|
|
|
rv = IR_TargetIsCaptionFrame(aPresContext, aDesiredSize, aReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-10-22 02:29:00 +04:00
|
|
|
const nsStyleDisplay* nextDisplay;
|
|
|
|
aNextFrame->GetStyleData(eStyleStruct_Display, (const nsStyleStruct *&)nextDisplay);
|
|
|
|
if (NS_STYLE_DISPLAY_TABLE_HEADER_GROUP==nextDisplay->mDisplay ||
|
|
|
|
NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP==nextDisplay->mDisplay ||
|
|
|
|
NS_STYLE_DISPLAY_TABLE_ROW_GROUP ==nextDisplay->mDisplay ||
|
1999-04-04 04:06:48 +04:00
|
|
|
NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP==nextDisplay->mDisplay) {
|
1998-10-22 02:29:00 +04:00
|
|
|
rv = IR_TargetIsInnerTableFrame(aPresContext, aDesiredSize, aReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-10-22 02:29:00 +04:00
|
|
|
NS_ASSERTION(PR_FALSE, "illegal next frame in incremental reflow.");
|
|
|
|
rv = NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
}
|
|
|
|
}
|
1998-10-08 19:34:48 +04:00
|
|
|
return rv;
|
|
|
|
}
|
1998-06-19 04:34:12 +04:00
|
|
|
|
1998-10-08 19:34:48 +04:00
|
|
|
nsresult nsTableOuterFrame::IR_TargetIsInnerTableFrame(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
|
|
|
nsresult rv = IR_InnerTableReflow(aPresContext, aDesiredSize, aReflowState, aStatus);
|
|
|
|
return rv;
|
|
|
|
}
|
1998-06-19 09:21:45 +04:00
|
|
|
|
1998-10-08 19:34:48 +04:00
|
|
|
nsresult nsTableOuterFrame::IR_TargetIsCaptionFrame(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
1999-04-04 04:06:48 +04:00
|
|
|
PRBool innerTableNeedsReflow = PR_FALSE;
|
1998-10-09 23:59:45 +04:00
|
|
|
// remember the old width and height
|
|
|
|
nsRect priorCaptionRect;
|
|
|
|
mCaptionFrame->GetRect(priorCaptionRect);
|
|
|
|
// if the reflow type is a style change, also remember the prior style
|
|
|
|
nsIReflowCommand::ReflowType reflowCommandType;
|
|
|
|
aReflowState.reflowState.reflowCommand->GetType(reflowCommandType);
|
1999-04-04 04:06:48 +04:00
|
|
|
const nsStyleText* priorCaptionTextStyle = nsnull;
|
|
|
|
if (nsIReflowCommand::StyleChanged == reflowCommandType) {
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Text, ((const nsStyleStruct *&)priorCaptionTextStyle));
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-09 23:59:45 +04:00
|
|
|
|
|
|
|
// pass along the reflow command to the caption
|
|
|
|
nsSize captionMES(0,0);
|
|
|
|
nsHTMLReflowMetrics captionSize(&captionMES);
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState captionReflowState(aPresContext, aReflowState.reflowState, mCaptionFrame,
|
|
|
|
nsSize(mRect.width, aReflowState.reflowState.availableHeight),
|
|
|
|
aReflowState.reflowState.reason);
|
|
|
|
captionReflowState.reflowCommand = aReflowState.reflowState.reflowCommand;
|
1998-10-09 23:59:45 +04:00
|
|
|
rv = ReflowChild(mCaptionFrame, aPresContext, captionSize, captionReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
1998-10-09 23:59:45 +04:00
|
|
|
return rv;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
if (mMinCaptionWidth != captionMES.width) {
|
|
|
|
// set the new caption min width, and set state to reflow the inner table if necessary
|
1998-10-09 23:59:45 +04:00
|
|
|
mMinCaptionWidth = captionMES.width;
|
1999-04-04 04:06:48 +04:00
|
|
|
if (mMinCaptionWidth > mRect.width) {
|
1998-10-09 23:59:45 +04:00
|
|
|
innerTableNeedsReflow=PR_TRUE;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-09 23:59:45 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// check if the caption alignment changed axis
|
1999-04-04 04:06:48 +04:00
|
|
|
if (nsIReflowCommand::StyleChanged == reflowCommandType) {
|
1998-10-09 23:59:45 +04:00
|
|
|
const nsStyleText* captionTextStyle;
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Text, ((const nsStyleStruct *&)captionTextStyle));
|
1999-04-04 04:06:48 +04:00
|
|
|
if (PR_TRUE == IR_CaptionChangedAxis(priorCaptionTextStyle, captionTextStyle)) {
|
1998-10-09 23:59:45 +04:00
|
|
|
innerTableNeedsReflow=PR_TRUE;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-09 23:59:45 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// if we've determined that the inner table needs to be reflowed, do it here
|
|
|
|
nsSize innerTableSize;
|
1999-04-04 04:06:48 +04:00
|
|
|
if (PR_TRUE == innerTableNeedsReflow) {
|
1998-10-09 23:59:45 +04:00
|
|
|
// Compute the width to use for the table. In the case of an auto sizing
|
|
|
|
// table this represents the maximum available width
|
1999-01-15 22:55:19 +03:00
|
|
|
nscoord tableWidth = ComputeAvailableTableWidth(aReflowState.reflowState);
|
1998-10-09 23:59:45 +04:00
|
|
|
|
|
|
|
// If the caption max element size is larger, then use it instead.
|
|
|
|
// XXX: caption align = left|right ignored here!
|
|
|
|
if (mMinCaptionWidth > tableWidth) {
|
|
|
|
tableWidth = mMinCaptionWidth;
|
|
|
|
}
|
|
|
|
nsHTMLReflowMetrics innerSize(aDesiredSize.maxElementSize);
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState innerReflowState(aPresContext, aReflowState.reflowState, mInnerTableFrame,
|
|
|
|
nsSize(tableWidth, aReflowState.reflowState.availableHeight),
|
|
|
|
eReflowReason_Resize);
|
1998-10-09 23:59:45 +04:00
|
|
|
rv = ReflowChild(mInnerTableFrame, aPresContext, innerSize, innerReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
1998-10-09 23:59:45 +04:00
|
|
|
return rv;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-09 23:59:45 +04:00
|
|
|
innerTableSize.SizeTo(innerSize.width, innerSize.height);
|
|
|
|
// set maxElementSize width if requested
|
1999-04-04 04:06:48 +04:00
|
|
|
if (nsnull != aDesiredSize.maxElementSize) {
|
1998-10-09 23:59:45 +04:00
|
|
|
((nsTableFrame *)mInnerTableFrame)->SetMaxElementSize(aDesiredSize.maxElementSize);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (mMinCaptionWidth > aDesiredSize.maxElementSize->width) {
|
1998-10-09 23:59:45 +04:00
|
|
|
aDesiredSize.maxElementSize->width = mMinCaptionWidth;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-04-04 04:06:48 +04:00
|
|
|
else {
|
1998-10-09 23:59:45 +04:00
|
|
|
nsRect innerTableRect;
|
|
|
|
mInnerTableFrame->GetRect(innerTableRect);
|
|
|
|
innerTableSize.SizeTo(innerTableRect.width, innerTableRect.height);
|
|
|
|
}
|
|
|
|
|
|
|
|
// regardless of what we've done up to this point, place the caption and inner table
|
|
|
|
rv = SizeAndPlaceChildren(innerTableSize,
|
|
|
|
nsSize (captionSize.width, captionSize.height),
|
|
|
|
aReflowState);
|
|
|
|
|
1998-10-08 19:34:48 +04:00
|
|
|
return rv;
|
|
|
|
}
|
1998-06-19 09:21:45 +04:00
|
|
|
|
1999-08-10 07:52:15 +04:00
|
|
|
nsresult
|
|
|
|
nsTableOuterFrame::IR_ReflowDirty(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
1998-10-08 19:34:48 +04:00
|
|
|
{
|
1999-08-10 07:52:15 +04:00
|
|
|
nsFrameState frameState;
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
// See if the caption frame is dirty. This would be because of a newly
|
|
|
|
// inserted caption
|
|
|
|
if (mCaptionFrame) {
|
|
|
|
mCaptionFrame->GetFrameState(&frameState);
|
|
|
|
if (frameState & NS_FRAME_IS_DIRTY) {
|
|
|
|
rv = IR_CaptionInserted(aPresContext, aDesiredSize, aReflowState, aStatus);
|
|
|
|
|
|
|
|
// Repaint our entire bounds
|
|
|
|
// XXX Improve this...
|
|
|
|
Invalidate(nsRect(0, 0, mRect.width, mRect.height));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// See if the inner table frame is dirty
|
|
|
|
mInnerTableFrame->GetFrameState(&frameState);
|
|
|
|
if (frameState & NS_FRAME_IS_DIRTY) {
|
1999-08-02 02:01:37 +04:00
|
|
|
// Inner table is dirty so reflow it. Change the reflow state and set the
|
|
|
|
// reason to resize reflow.
|
|
|
|
((nsHTMLReflowState&)aReflowState.reflowState).reason = eReflowReason_Resize;
|
|
|
|
((nsHTMLReflowState&)aReflowState.reflowState).reflowCommand = nsnull;
|
|
|
|
|
|
|
|
// Get the inner table frame's current bounds. We'll use that when
|
|
|
|
// repainting it
|
|
|
|
// XXX It should really do the repainting, but because it think it's
|
|
|
|
// getting a resize reflow it won't know to...
|
|
|
|
nsRect dirtyRect;
|
|
|
|
mInnerTableFrame->GetRect(dirtyRect);
|
|
|
|
rv = IR_InnerTableReflow(aPresContext, aDesiredSize, aReflowState, aStatus);
|
|
|
|
|
|
|
|
// Repaint the inner table frame's entire visible area
|
|
|
|
dirtyRect.x = dirtyRect.y = 0;
|
|
|
|
Invalidate(dirtyRect);
|
|
|
|
|
1999-08-10 07:52:15 +04:00
|
|
|
} else if (!mCaptionFrame) {
|
|
|
|
// The inner table isn't dirty so we don't need to reflow it, but make
|
|
|
|
// sure it's placed correctly. It could be that we're dirty because the
|
|
|
|
// caption was removed
|
|
|
|
mInnerTableFrame->MoveTo(0,0);
|
|
|
|
|
|
|
|
// Update our state so we calculate our desired size correctly
|
|
|
|
nsRect innerRect;
|
|
|
|
mInnerTableFrame->GetRect(innerRect);
|
|
|
|
aReflowState.innerTableMaxSize.width = innerRect.width;
|
|
|
|
aReflowState.y = innerRect.height;
|
|
|
|
|
|
|
|
// Repaint our entire bounds
|
|
|
|
// XXX Improve this...
|
|
|
|
Invalidate(nsRect(0, 0, mRect.width, mRect.height));
|
1998-06-19 09:21:45 +04:00
|
|
|
}
|
1998-06-19 04:34:12 +04:00
|
|
|
|
1999-08-10 07:52:15 +04:00
|
|
|
return rv;
|
|
|
|
}
|
1998-06-23 09:43:27 +04:00
|
|
|
|
1999-08-10 07:52:15 +04:00
|
|
|
// IR_TargetIsMe is free to foward the request to the inner table frame
|
|
|
|
nsresult nsTableOuterFrame::IR_TargetIsMe(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsIReflowCommand::ReflowType type;
|
|
|
|
aReflowState.reflowState.reflowCommand->GetType(type);
|
|
|
|
nsIFrame* objectFrame;
|
|
|
|
aReflowState.reflowState.reflowCommand->GetChildFrame(objectFrame);
|
|
|
|
switch (type) {
|
|
|
|
case nsIReflowCommand::ReflowDirty:
|
1999-08-19 23:52:37 +04:00
|
|
|
rv = IR_ReflowDirty(aPresContext, aDesiredSize, aReflowState, aStatus);
|
1998-10-08 19:34:48 +04:00
|
|
|
break;
|
1998-09-30 22:11:48 +04:00
|
|
|
|
1999-08-19 23:52:37 +04:00
|
|
|
case nsIReflowCommand::StyleChanged :
|
1998-10-30 10:57:44 +03:00
|
|
|
rv = IR_InnerTableReflow(aPresContext, aDesiredSize, aReflowState, aStatus);
|
1998-10-08 19:34:48 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case nsIReflowCommand::ContentChanged :
|
|
|
|
NS_ASSERTION(PR_FALSE, "illegal reflow type: ContentChanged");
|
|
|
|
rv = NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
break;
|
1998-10-01 08:46:11 +04:00
|
|
|
|
1999-03-05 07:19:09 +03:00
|
|
|
default:
|
1999-08-10 07:52:15 +04:00
|
|
|
NS_NOTYETIMPLEMENTED("unexpected reflow command type");
|
1998-10-08 19:34:48 +04:00
|
|
|
rv = NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult nsTableOuterFrame::IR_InnerTableReflow(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
|
|
|
nsReflowStatus& aStatus)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
const nsStyleText* captionTextStyle=nsnull;
|
|
|
|
nsMargin captionMargin;
|
|
|
|
// remember the old width and height
|
|
|
|
nsRect priorInnerTableRect;
|
|
|
|
mInnerTableFrame->GetRect(priorInnerTableRect);
|
|
|
|
// pass along the reflow command to the inner table
|
|
|
|
nsHTMLReflowMetrics innerSize(aDesiredSize.maxElementSize);
|
1999-01-06 02:31:18 +03:00
|
|
|
nscoord tableMaxWidth = PR_MAX(aReflowState.reflowState.availableWidth, mMinCaptionWidth);
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState innerReflowState(aPresContext, aReflowState.reflowState, mInnerTableFrame,
|
1999-01-06 02:31:18 +03:00
|
|
|
nsSize(tableMaxWidth, aReflowState.reflowState.availableHeight));
|
1998-10-08 19:34:48 +04:00
|
|
|
rv = ReflowChild(mInnerTableFrame, aPresContext, innerSize, innerReflowState, aStatus);
|
|
|
|
// if there is a caption and the width or height of the inner table changed from a successful reflow,
|
|
|
|
// then reflow or move the caption as needed
|
1999-04-04 04:06:48 +04:00
|
|
|
if ((nsnull != mCaptionFrame) && (PR_TRUE==NS_SUCCEEDED(rv))) {
|
1998-10-08 19:34:48 +04:00
|
|
|
// remember the old caption height
|
|
|
|
nsRect oldCaptionRect;
|
|
|
|
mCaptionFrame->GetRect(oldCaptionRect);
|
|
|
|
nsHTMLReflowMetrics captionSize(nsnull); // don't ask for MES, it hasn't changed
|
1999-04-04 04:06:48 +04:00
|
|
|
PRBool captionDimChanged = PR_FALSE;
|
|
|
|
PRBool captionWasReflowed = PR_FALSE;
|
|
|
|
if (priorInnerTableRect.width != innerSize.width) {
|
|
|
|
// the table width changed, so reflow the caption
|
|
|
|
nsHTMLReflowState captionReflowState(aPresContext, aReflowState.reflowState, mCaptionFrame,
|
|
|
|
nsSize(innerSize.width, aReflowState.reflowState.availableHeight),
|
|
|
|
eReflowReason_Resize);
|
|
|
|
nsIHTMLReflow* htmlReflow;
|
|
|
|
if (NS_OK == mCaptionFrame->QueryInterface(kIHTMLReflowIID, (void**)&htmlReflow)) {
|
|
|
|
// reflow the caption
|
1998-10-08 19:34:48 +04:00
|
|
|
htmlReflow->WillReflow(aPresContext);
|
|
|
|
rv = htmlReflow->Reflow(aPresContext, captionSize, captionReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
captionWasReflowed = PR_TRUE;
|
|
|
|
if ((oldCaptionRect.height!=captionSize.height) ||
|
|
|
|
(oldCaptionRect.width!=captionSize.width)) {
|
1998-10-08 19:34:48 +04:00
|
|
|
captionDimChanged=PR_TRUE;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-08 19:34:48 +04:00
|
|
|
}
|
|
|
|
}
|
1998-10-09 23:59:45 +04:00
|
|
|
// XXX: should just call SizeAndPlaceChildren regardless
|
1998-10-08 19:34:48 +04:00
|
|
|
// find where to place the caption
|
|
|
|
const nsStyleSpacing* spacing;
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing);
|
1998-10-08 19:34:48 +04:00
|
|
|
spacing->CalcMarginFor(mCaptionFrame, captionMargin);
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Text, ((const nsStyleStruct *&)captionTextStyle));
|
1999-04-04 04:06:48 +04:00
|
|
|
if ((priorInnerTableRect.height!=innerSize.height) ||
|
|
|
|
(PR_TRUE==captionDimChanged)) {
|
1998-10-08 19:34:48 +04:00
|
|
|
// Compute the caption's y-origin
|
|
|
|
nscoord captionY = captionMargin.top;
|
|
|
|
if ((captionTextStyle->mVerticalAlign.GetUnit()==eStyleUnit_Enumerated) &&
|
1999-04-04 04:06:48 +04:00
|
|
|
(captionTextStyle->mVerticalAlign.GetIntValue()==NS_STYLE_VERTICAL_ALIGN_BOTTOM)) {
|
1998-10-08 19:34:48 +04:00
|
|
|
captionY += innerSize.height;
|
|
|
|
}
|
|
|
|
// Place the caption
|
|
|
|
nsRect captionRect(captionMargin.left, captionY, 0, 0);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (PR_TRUE==captionWasReflowed) {
|
1998-10-08 19:34:48 +04:00
|
|
|
captionRect.SizeTo(captionSize.width, captionSize.height);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-10-08 19:34:48 +04:00
|
|
|
captionRect.SizeTo(oldCaptionRect.width, oldCaptionRect.height);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-08 19:34:48 +04:00
|
|
|
mCaptionFrame->SetRect(captionRect);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if anything above failed, we just want to return an error at this point
|
1999-04-04 04:06:48 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
1998-10-08 19:34:48 +04:00
|
|
|
return rv;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-08 19:34:48 +04:00
|
|
|
// Place the inner table
|
|
|
|
nsRect updatedCaptionRect(0,0,0,0);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (nsnull != mCaptionFrame) {
|
1998-10-08 19:34:48 +04:00
|
|
|
mCaptionFrame->GetRect(updatedCaptionRect);
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-08 19:34:48 +04:00
|
|
|
nscoord innerY; // innerY is the y-offset of the inner table
|
1999-04-04 04:06:48 +04:00
|
|
|
if (nsnull != mCaptionFrame) {
|
|
|
|
// factor in caption and it's margin
|
1998-10-08 19:34:48 +04:00
|
|
|
// we're guaranteed that captionMargin and captionTextStyle are set at this point
|
1999-04-04 04:06:48 +04:00
|
|
|
if ((captionTextStyle->mVerticalAlign.GetUnit() == eStyleUnit_Enumerated) &&
|
|
|
|
(captionTextStyle->mVerticalAlign.GetIntValue() == NS_STYLE_VERTICAL_ALIGN_BOTTOM)) {
|
|
|
|
// bottom caption
|
1998-10-08 19:34:48 +04:00
|
|
|
innerY = 0; // the inner table goes at the top of the outer table
|
|
|
|
// the total v-space consumed is the inner table height + the caption height + the margin between them
|
|
|
|
aReflowState.y = innerSize.height + updatedCaptionRect.YMost() + captionMargin.top;
|
|
|
|
}
|
1999-04-04 04:06:48 +04:00
|
|
|
else { // top caption
|
1998-10-08 19:34:48 +04:00
|
|
|
innerY = updatedCaptionRect.YMost() + captionMargin.bottom;
|
|
|
|
// the total v-space consumed is the inner table height + the caption height + the margin between them
|
|
|
|
aReflowState.y = innerY + innerSize.height;
|
|
|
|
}
|
|
|
|
}
|
1999-04-04 04:06:48 +04:00
|
|
|
else { // no caption
|
1998-10-08 19:34:48 +04:00
|
|
|
innerY=0;
|
|
|
|
aReflowState.y = innerSize.height;
|
|
|
|
}
|
|
|
|
nsRect innerRect(0, innerY, innerSize.width, innerSize.height);
|
|
|
|
mInnerTableFrame->SetRect(innerRect);
|
1998-10-09 23:59:45 +04:00
|
|
|
|
|
|
|
aReflowState.innerTableMaxSize.width = innerSize.width;
|
1998-10-08 19:34:48 +04:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* the only difference between an insert and a replace is a replace
|
|
|
|
checks the old maxElementSize and reflows the table only if it
|
|
|
|
has changed
|
|
|
|
*/
|
|
|
|
nsresult nsTableOuterFrame::IR_CaptionInserted(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
|
|
OuterTableReflowState& aReflowState,
|
1999-08-10 07:52:15 +04:00
|
|
|
nsReflowStatus& aStatus)
|
1999-08-19 23:52:37 +04:00
|
|
|
{
|
1998-10-08 19:34:48 +04:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
// reflow the caption frame, getting it's MES
|
|
|
|
nsSize maxElementSize;
|
|
|
|
nsHTMLReflowMetrics captionSize(&maxElementSize);
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState captionReflowState(aPresContext, aReflowState.reflowState, mCaptionFrame,
|
1999-01-06 02:31:18 +03:00
|
|
|
nsSize(mRect.width, aReflowState.reflowState.availableHeight),
|
1998-10-08 19:34:48 +04:00
|
|
|
eReflowReason_Initial);
|
|
|
|
nsIHTMLReflow* htmlReflow;
|
|
|
|
|
1999-04-04 04:06:48 +04:00
|
|
|
if (NS_OK == mCaptionFrame->QueryInterface(kIHTMLReflowIID, (void**)&htmlReflow)) {
|
|
|
|
// initial reflow of the caption
|
1998-10-08 19:34:48 +04:00
|
|
|
htmlReflow->WillReflow(aPresContext);
|
1998-10-09 23:59:45 +04:00
|
|
|
rv = htmlReflow->Reflow(aPresContext, captionSize, captionReflowState, aStatus);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (NS_FAILED(rv)) {
|
1998-10-09 23:59:45 +04:00
|
|
|
return rv;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-10-08 19:34:48 +04:00
|
|
|
mMinCaptionWidth = maxElementSize.width;
|
|
|
|
// get the caption's alignment
|
|
|
|
const nsStyleText* captionTextStyle;
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Text, ((const nsStyleStruct *&)captionTextStyle));
|
1999-04-04 04:06:48 +04:00
|
|
|
nsStyleUnit vAlignUnit = captionTextStyle->mVerticalAlign.GetUnit();
|
1998-10-09 23:59:45 +04:00
|
|
|
if (PR_TRUE || // XXX: this is a hack because we don't support left|right captions yet
|
1999-04-04 04:06:48 +04:00
|
|
|
(vAlignUnit != eStyleUnit_Enumerated) || // default is "top"
|
|
|
|
((vAlignUnit == eStyleUnit_Enumerated) &&
|
|
|
|
((vAlignUnit == NS_STYLE_VERTICAL_ALIGN_TOP) ||
|
|
|
|
(vAlignUnit == NS_STYLE_VERTICAL_ALIGN_BOTTOM)))) {
|
1998-10-08 19:34:48 +04:00
|
|
|
// XXX: caption align = left|right ignored here!
|
1998-10-09 23:59:45 +04:00
|
|
|
// if the caption's MES > table width, reflow the inner table
|
1998-10-08 19:34:48 +04:00
|
|
|
nsHTMLReflowMetrics innerSize(aDesiredSize.maxElementSize);
|
1999-08-10 07:52:15 +04:00
|
|
|
if (mMinCaptionWidth > mRect.width) {
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState innerReflowState(aPresContext, aReflowState.reflowState, mInnerTableFrame,
|
1999-01-06 02:31:18 +03:00
|
|
|
nsSize(mMinCaptionWidth, aReflowState.reflowState.availableHeight),
|
1998-10-09 23:59:45 +04:00
|
|
|
eReflowReason_Resize);
|
1998-10-08 19:34:48 +04:00
|
|
|
rv = ReflowChild(mInnerTableFrame, aPresContext, innerSize, innerReflowState, aStatus);
|
|
|
|
}
|
1999-04-04 04:06:48 +04:00
|
|
|
else { // set innerSize as if the inner table were reflowed
|
1998-10-08 19:34:48 +04:00
|
|
|
innerSize.height = mRect.height;
|
1999-04-04 04:06:48 +04:00
|
|
|
innerSize.width = mRect.width;
|
1998-10-08 19:34:48 +04:00
|
|
|
}
|
|
|
|
// set maxElementSize width if requested
|
1999-04-04 04:06:48 +04:00
|
|
|
if (nsnull != aDesiredSize.maxElementSize) {
|
1998-10-09 23:59:45 +04:00
|
|
|
((nsTableFrame *)mInnerTableFrame)->SetMaxElementSize(aDesiredSize.maxElementSize);
|
1999-04-04 04:06:48 +04:00
|
|
|
if (mMinCaptionWidth > aDesiredSize.maxElementSize->width) {
|
1998-10-08 19:34:48 +04:00
|
|
|
aDesiredSize.maxElementSize->width = mMinCaptionWidth;
|
|
|
|
}
|
|
|
|
}
|
1998-10-09 23:59:45 +04:00
|
|
|
|
|
|
|
rv = SizeAndPlaceChildren(nsSize (innerSize.width, innerSize.height),
|
|
|
|
nsSize (captionSize.width, captionSize.height),
|
|
|
|
aReflowState);
|
1998-10-08 19:34:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1998-10-09 23:59:45 +04:00
|
|
|
PRBool nsTableOuterFrame::IR_CaptionChangedAxis(const nsStyleText* aOldStyle,
|
|
|
|
const nsStyleText* aNewStyle) const
|
|
|
|
{
|
|
|
|
PRBool result = PR_FALSE;
|
|
|
|
//XXX: write me to support left|right captions!
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-04-04 04:06:48 +04:00
|
|
|
nsresult nsTableOuterFrame::SizeAndPlaceChildren(const nsSize& aInnerSize,
|
|
|
|
const nsSize& aCaptionSize,
|
|
|
|
OuterTableReflowState& aReflowState)
|
1998-10-09 23:59:45 +04:00
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
// find where to place the caption
|
|
|
|
nsMargin captionMargin;
|
|
|
|
const nsStyleSpacing* spacing;
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing);
|
1998-10-09 23:59:45 +04:00
|
|
|
spacing->CalcMarginFor(mCaptionFrame, captionMargin);
|
|
|
|
// Compute the caption's y-origin
|
|
|
|
nscoord captionY = captionMargin.top;
|
|
|
|
const nsStyleText* captionTextStyle;
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Text, ((const nsStyleStruct *&)captionTextStyle));
|
1998-10-09 23:59:45 +04:00
|
|
|
if ((captionTextStyle->mVerticalAlign.GetUnit()==eStyleUnit_Enumerated) &&
|
1999-04-04 04:06:48 +04:00
|
|
|
(captionTextStyle->mVerticalAlign.GetIntValue()==NS_STYLE_VERTICAL_ALIGN_BOTTOM)) {
|
1998-10-09 23:59:45 +04:00
|
|
|
captionY += aInnerSize.height;
|
|
|
|
}
|
|
|
|
// Place the caption
|
|
|
|
nsRect captionRect(captionMargin.left, captionY, 0, 0);
|
|
|
|
captionRect.SizeTo(aCaptionSize.width, aCaptionSize.height);
|
|
|
|
mCaptionFrame->SetRect(captionRect);
|
|
|
|
|
|
|
|
// Place the inner table
|
|
|
|
nscoord innerY;
|
|
|
|
if ((captionTextStyle->mVerticalAlign.GetUnit()==eStyleUnit_Enumerated) &&
|
1999-04-04 04:06:48 +04:00
|
|
|
(captionTextStyle->mVerticalAlign.GetIntValue()==NS_STYLE_VERTICAL_ALIGN_BOTTOM)) {
|
|
|
|
// bottom caption
|
1998-10-09 23:59:45 +04:00
|
|
|
innerY = 0;
|
|
|
|
aReflowState.y = captionRect.YMost() + captionMargin.bottom;
|
|
|
|
}
|
1999-04-04 04:06:48 +04:00
|
|
|
else { // top caption
|
1998-10-09 23:59:45 +04:00
|
|
|
innerY = captionRect.YMost() + captionMargin.bottom;
|
|
|
|
aReflowState.y = innerY + aInnerSize.height;
|
|
|
|
}
|
|
|
|
nsRect innerRect(0, innerY, aInnerSize.width, aInnerSize.height);
|
|
|
|
mInnerTableFrame->SetRect(innerRect);
|
|
|
|
aReflowState.innerTableMaxSize.width = aInnerSize.width;
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-04-04 04:06:48 +04:00
|
|
|
// computes the table width
|
1999-01-15 22:55:19 +03:00
|
|
|
nscoord nsTableOuterFrame::ComputeAvailableTableWidth(const nsHTMLReflowState& aReflowState)
|
1998-07-09 18:30:34 +04:00
|
|
|
{
|
|
|
|
nscoord maxWidth;
|
|
|
|
|
|
|
|
// Figure out the overall table width constraint. Default case, get 100% of
|
|
|
|
// available space
|
1999-01-06 02:31:18 +03:00
|
|
|
if (NS_UNCONSTRAINEDSIZE == aReflowState.availableWidth) {
|
|
|
|
maxWidth = aReflowState.availableWidth;
|
1998-07-09 18:30:34 +04:00
|
|
|
|
|
|
|
} else {
|
|
|
|
const nsStylePosition* position =
|
|
|
|
(const nsStylePosition*)mStyleContext->GetStyleData(eStyleStruct_Position);
|
|
|
|
|
|
|
|
switch (position->mWidth.GetUnit()) {
|
|
|
|
case eStyleUnit_Coord:
|
|
|
|
maxWidth = position->mWidth.GetCoordValue();
|
1998-11-25 21:43:56 +03:00
|
|
|
// NAV4 compatibility: 0-coord-width == auto-width
|
1999-03-06 08:03:09 +03:00
|
|
|
// XXX This doesn't belong here. If the HTML attribute "width=0" should work
|
|
|
|
// like 'auto', then have the style mapping code in the content object
|
|
|
|
// handle it...
|
1999-04-04 04:06:48 +04:00
|
|
|
if (0 == maxWidth) {
|
1999-01-06 02:31:18 +03:00
|
|
|
maxWidth = aReflowState.availableWidth;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-07-09 18:30:34 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case eStyleUnit_Auto:
|
1999-01-06 02:31:18 +03:00
|
|
|
maxWidth = aReflowState.availableWidth;
|
1998-07-09 18:30:34 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case eStyleUnit_Percent:
|
1999-04-04 04:06:48 +04:00
|
|
|
maxWidth = (nscoord)((float)aReflowState.availableWidth * position->mWidth.GetPercentValue());
|
1998-11-25 21:43:56 +03:00
|
|
|
// NAV4 compatibility: 0-percent-width == auto-width
|
1999-03-06 08:03:09 +03:00
|
|
|
// XXX Ditto...
|
1999-04-04 04:06:48 +04:00
|
|
|
if (0 == maxWidth) {
|
1999-01-06 02:31:18 +03:00
|
|
|
maxWidth = aReflowState.availableWidth;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
1998-07-09 18:30:34 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case eStyleUnit_Proportional:
|
|
|
|
case eStyleUnit_Inherit:
|
|
|
|
// XXX for now these fall through
|
|
|
|
|
|
|
|
default:
|
1999-01-06 02:31:18 +03:00
|
|
|
maxWidth = aReflowState.availableWidth;
|
1998-07-09 18:30:34 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Subtract out border and padding
|
|
|
|
const nsStyleSpacing* spacing =
|
|
|
|
(const nsStyleSpacing*)mStyleContext->GetStyleData(eStyleStruct_Spacing);
|
|
|
|
nsMargin borderPadding;
|
|
|
|
spacing->CalcBorderPaddingFor(this, borderPadding);
|
|
|
|
|
|
|
|
maxWidth -= borderPadding.left + borderPadding.right;
|
|
|
|
if (maxWidth <= 0) {
|
|
|
|
// Nonsense style specification
|
|
|
|
maxWidth = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return maxWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reflow is a multi-step process.
|
|
|
|
* 1. First we reflow the caption frame and get its maximum element size. We
|
|
|
|
* do this once during our initial reflow and whenever the caption changes
|
|
|
|
* incrementally
|
|
|
|
* 2. Next we reflow the inner table. This gives us the actual table width.
|
|
|
|
* The table must be at least as wide as the caption maximum element size
|
|
|
|
* 3. Now that we have the table width we reflow the caption and gets its
|
|
|
|
* desired height
|
|
|
|
* 4. Then we place the caption and the inner table
|
|
|
|
*
|
|
|
|
* If the table height is constrained, e.g. page mode, then it's possible the
|
|
|
|
* inner table no longer fits and has to be reflowed again this time with s
|
|
|
|
* smaller available height
|
1998-04-14 00:24:54 +04:00
|
|
|
*/
|
1999-04-04 04:06:48 +04:00
|
|
|
NS_METHOD nsTableOuterFrame::Reflow(nsIPresContext& aPresContext,
|
|
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
1998-10-02 08:10:00 +04:00
|
|
|
const nsHTMLReflowState& aReflowState,
|
1999-04-04 04:06:48 +04:00
|
|
|
nsReflowStatus& aStatus)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
1999-08-27 08:29:05 +04:00
|
|
|
if (nsDebugTable::gRflTableOuter) nsTableFrame::DebugReflow("TO::Rfl en", this, &aReflowState, nsnull);
|
1998-10-09 23:59:45 +04:00
|
|
|
nsresult rv = NS_OK;
|
1998-07-02 21:40:56 +04:00
|
|
|
|
1998-06-23 01:59:43 +04:00
|
|
|
// Initialize out parameters
|
1999-04-04 04:06:48 +04:00
|
|
|
aDesiredSize.width = 0;
|
1998-10-08 19:34:48 +04:00
|
|
|
aDesiredSize.height = 0;
|
1998-05-25 21:31:49 +04:00
|
|
|
if (nsnull != aDesiredSize.maxElementSize) {
|
|
|
|
aDesiredSize.maxElementSize->width = 0;
|
|
|
|
aDesiredSize.maxElementSize->height = 0;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
1998-06-23 01:59:43 +04:00
|
|
|
aStatus = NS_FRAME_COMPLETE;
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1998-06-19 09:21:45 +04:00
|
|
|
// Initialize our local reflow state
|
1998-10-08 19:34:48 +04:00
|
|
|
OuterTableReflowState state(aPresContext, aReflowState);
|
1998-06-19 04:34:12 +04:00
|
|
|
if (eReflowReason_Incremental == aReflowState.reason) {
|
1998-10-09 23:59:45 +04:00
|
|
|
rv = IncrementalReflow(aPresContext, aDesiredSize, state, aStatus);
|
1998-06-19 04:34:12 +04:00
|
|
|
} else {
|
1998-06-23 01:59:43 +04:00
|
|
|
if (eReflowReason_Initial == aReflowState.reason) {
|
|
|
|
// Set up our kids. They're already present, on an overflow list,
|
|
|
|
// or there are none so we'll create them now
|
|
|
|
MoveOverflowToChildList();
|
|
|
|
|
1998-07-09 18:30:34 +04:00
|
|
|
// Lay out the caption and get its maximum element size
|
1998-07-09 00:21:17 +04:00
|
|
|
if (nsnull != mCaptionFrame) {
|
1998-10-01 08:46:11 +04:00
|
|
|
nsSize maxElementSize;
|
|
|
|
nsHTMLReflowMetrics captionSize(&maxElementSize);
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState captionReflowState(aPresContext, aReflowState, mCaptionFrame,
|
1998-10-01 08:46:11 +04:00
|
|
|
nsSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE),
|
|
|
|
eReflowReason_Initial);
|
|
|
|
nsIHTMLReflow* htmlReflow;
|
|
|
|
|
|
|
|
if (NS_OK == mCaptionFrame->QueryInterface(kIHTMLReflowIID, (void**)&htmlReflow)) {
|
|
|
|
htmlReflow->WillReflow(aPresContext);
|
1998-10-09 23:59:45 +04:00
|
|
|
rv = htmlReflow->Reflow(aPresContext, captionSize, captionReflowState, aStatus);
|
1998-10-01 08:46:11 +04:00
|
|
|
mMinCaptionWidth = maxElementSize.width;
|
|
|
|
}
|
1998-07-09 00:21:17 +04:00
|
|
|
}
|
1998-06-19 04:34:12 +04:00
|
|
|
}
|
1998-06-23 01:59:43 +04:00
|
|
|
|
1998-09-20 08:50:08 +04:00
|
|
|
// At this point, we must have an inner table frame, and we might have a caption
|
1999-01-16 01:52:05 +03:00
|
|
|
NS_ASSERTION(mFrames.NotEmpty(), "no children");
|
1998-07-09 00:21:17 +04:00
|
|
|
NS_ASSERTION(nsnull != mInnerTableFrame, "no mInnerTableFrame");
|
1998-07-02 21:40:56 +04:00
|
|
|
|
1998-07-09 18:30:34 +04:00
|
|
|
// Compute the width to use for the table. In the case of an auto sizing
|
|
|
|
// table this represents the maximum available width
|
1999-01-15 22:55:19 +03:00
|
|
|
nscoord tableWidth = ComputeAvailableTableWidth(aReflowState);
|
1998-07-09 18:30:34 +04:00
|
|
|
|
|
|
|
// If the caption max element size is larger, then use it instead.
|
1998-10-08 19:34:48 +04:00
|
|
|
// XXX: caption align = left|right ignored here!
|
1998-07-09 18:30:34 +04:00
|
|
|
if (mMinCaptionWidth > tableWidth) {
|
|
|
|
tableWidth = mMinCaptionWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
// First reflow the inner table
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState innerReflowState(aPresContext, aReflowState, mInnerTableFrame,
|
1999-01-06 02:31:18 +03:00
|
|
|
nsSize(tableWidth, aReflowState.availableHeight));
|
1999-08-28 01:15:21 +04:00
|
|
|
innerReflowState.mComputedWidth = aReflowState.mComputedWidth;
|
|
|
|
if ((NS_UNCONSTRAINEDSIZE != tableWidth) &&
|
|
|
|
(tableWidth > aReflowState.mComputedWidth)) {
|
|
|
|
innerReflowState.mComputedWidth = tableWidth;
|
|
|
|
}
|
|
|
|
innerReflowState.mComputedHeight = aReflowState.mComputedHeight;
|
1998-10-01 08:46:11 +04:00
|
|
|
nsHTMLReflowMetrics innerSize(aDesiredSize.maxElementSize);
|
1998-10-06 04:27:22 +04:00
|
|
|
|
1998-10-09 23:59:45 +04:00
|
|
|
rv = ReflowChild(mInnerTableFrame, aPresContext, innerSize, innerReflowState, aStatus);
|
1998-10-06 04:27:22 +04:00
|
|
|
|
|
|
|
// Table's max element size is the MAX of the caption's max element size
|
|
|
|
// and the inner table's max element size...
|
|
|
|
if (nsnull != aDesiredSize.maxElementSize) {
|
|
|
|
if (mMinCaptionWidth > aDesiredSize.maxElementSize->width) {
|
|
|
|
aDesiredSize.maxElementSize->width = mMinCaptionWidth;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
1998-06-19 04:34:12 +04:00
|
|
|
}
|
1998-07-09 18:30:34 +04:00
|
|
|
state.innerTableMaxSize.width = innerSize.width;
|
|
|
|
|
|
|
|
// Now that we know the table width we can reflow the caption, and
|
|
|
|
// place the caption and the inner table
|
|
|
|
if (nsnull != mCaptionFrame) {
|
|
|
|
// Get the caption's margin
|
|
|
|
nsMargin captionMargin;
|
|
|
|
const nsStyleSpacing* spacing;
|
|
|
|
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Spacing, (const nsStyleStruct *&)spacing);
|
1998-07-09 18:30:34 +04:00
|
|
|
spacing->CalcMarginFor(mCaptionFrame, captionMargin);
|
|
|
|
|
|
|
|
// Compute the caption's y-origin
|
|
|
|
nscoord captionY = captionMargin.top;
|
1998-09-20 08:50:08 +04:00
|
|
|
const nsStyleText* captionTextStyle;
|
1998-12-02 19:45:20 +03:00
|
|
|
mCaptionFrame->GetStyleData(eStyleStruct_Text, ((const nsStyleStruct *&)captionTextStyle));
|
1998-09-20 08:50:08 +04:00
|
|
|
if ((captionTextStyle->mVerticalAlign.GetUnit()==eStyleUnit_Enumerated) &&
|
|
|
|
(captionTextStyle->mVerticalAlign.GetIntValue()==NS_STYLE_VERTICAL_ALIGN_BOTTOM)) {
|
1998-07-09 18:30:34 +04:00
|
|
|
captionY += innerSize.height;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reflow the caption. Let it be as high as it wants
|
1999-04-04 04:06:48 +04:00
|
|
|
nsHTMLReflowState captionReflowState(aPresContext, state.reflowState, mCaptionFrame,
|
1998-10-02 08:10:00 +04:00
|
|
|
nsSize(innerSize.width, NS_UNCONSTRAINEDSIZE),
|
|
|
|
eReflowReason_Resize);
|
1998-10-01 08:46:11 +04:00
|
|
|
nsHTMLReflowMetrics captionSize(nsnull);
|
|
|
|
nsIHTMLReflow* htmlReflow;
|
|
|
|
nsRect captionRect(captionMargin.left, captionY, 0, 0);
|
|
|
|
|
|
|
|
if (NS_OK == mCaptionFrame->QueryInterface(kIHTMLReflowIID, (void**)&htmlReflow)) {
|
|
|
|
nsReflowStatus captionStatus;
|
|
|
|
htmlReflow->WillReflow(aPresContext);
|
|
|
|
htmlReflow->Reflow(aPresContext, captionSize, captionReflowState,
|
|
|
|
captionStatus);
|
|
|
|
NS_ASSERTION(NS_FRAME_IS_COMPLETE(captionStatus), "unexpected reflow status");
|
|
|
|
|
|
|
|
// XXX If the height is constrained then we need to check whether the inner
|
|
|
|
// table still fits...
|
|
|
|
|
|
|
|
// Place the caption
|
|
|
|
captionRect.SizeTo(captionSize.width, captionSize.height);
|
|
|
|
mCaptionFrame->SetRect(captionRect);
|
|
|
|
}
|
1998-07-09 18:30:34 +04:00
|
|
|
|
|
|
|
// Place the inner table
|
|
|
|
nscoord innerY;
|
1998-09-20 08:50:08 +04:00
|
|
|
if ((captionTextStyle->mVerticalAlign.GetUnit()!=eStyleUnit_Enumerated) ||
|
|
|
|
(captionTextStyle->mVerticalAlign.GetIntValue()!=NS_STYLE_VERTICAL_ALIGN_BOTTOM)) {
|
|
|
|
// top caption
|
1998-07-09 18:30:34 +04:00
|
|
|
innerY = captionRect.YMost() + captionMargin.bottom;
|
|
|
|
state.y = innerY + innerSize.height;
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-09-20 08:50:08 +04:00
|
|
|
// bottom caption
|
1999-04-04 04:06:48 +04:00
|
|
|
innerY = 0;
|
1998-07-09 18:30:34 +04:00
|
|
|
state.y = captionRect.YMost() + captionMargin.bottom;
|
|
|
|
}
|
|
|
|
nsRect innerRect(0, innerY, innerSize.width, innerSize.height);
|
|
|
|
mInnerTableFrame->SetRect(innerRect);
|
|
|
|
|
1999-04-04 04:06:48 +04:00
|
|
|
}
|
|
|
|
else {
|
1998-07-09 18:30:34 +04:00
|
|
|
// Place the inner table
|
|
|
|
nsRect innerRect(0, 0, innerSize.width, innerSize.height);
|
|
|
|
mInnerTableFrame->SetRect(innerRect);
|
|
|
|
state.y = innerSize.height;
|
1998-06-19 04:34:12 +04:00
|
|
|
}
|
1998-06-19 09:21:45 +04:00
|
|
|
}
|
1998-06-19 04:34:12 +04:00
|
|
|
|
1998-07-09 18:30:34 +04:00
|
|
|
// Return our desired rect
|
1999-04-04 04:06:48 +04:00
|
|
|
aDesiredSize.width = state.innerTableMaxSize.width;
|
|
|
|
aDesiredSize.height = state.y;
|
|
|
|
aDesiredSize.ascent = aDesiredSize.height;
|
1998-07-03 01:24:56 +04:00
|
|
|
aDesiredSize.descent = 0;
|
1998-06-19 09:21:45 +04:00
|
|
|
|
1999-08-27 08:29:05 +04:00
|
|
|
if (nsDebugTable::gRflTableOuter) nsTableFrame::DebugReflow("TO::Rfl ex", this, nsnull, &aDesiredSize);
|
1998-10-09 23:59:45 +04:00
|
|
|
return rv;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Position and size aKidFrame and update our reflow state. The origin of
|
|
|
|
// aKidRect is relative to the upper-left origin of our frame, and includes
|
|
|
|
// any left/top margin.
|
1999-04-04 04:06:48 +04:00
|
|
|
void nsTableOuterFrame::PlaceChild(OuterTableReflowState& aReflowState,
|
|
|
|
nsIFrame* aKidFrame,
|
|
|
|
const nsRect& aKidRect,
|
|
|
|
nsSize* aMaxElementSize,
|
|
|
|
nsSize& aKidMaxElementSize)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
|
|
|
// Place and size the child
|
|
|
|
aKidFrame->SetRect(aKidRect);
|
|
|
|
|
|
|
|
// Adjust the running y-offset
|
1998-10-08 19:34:48 +04:00
|
|
|
aReflowState.y += aKidRect.height;
|
1998-04-14 00:24:54 +04:00
|
|
|
|
|
|
|
// If our height is constrained then update the available height
|
1998-10-08 19:34:48 +04:00
|
|
|
if (PR_FALSE == aReflowState.unconstrainedHeight) {
|
|
|
|
aReflowState.availSize.height -= aKidRect.height;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
|
|
|
|
1999-01-15 22:55:19 +03:00
|
|
|
/* Update the maximum element size, which is the max of:
|
1998-04-14 00:24:54 +04:00
|
|
|
* the maxElementSize of our first row
|
1999-01-15 22:55:19 +03:00
|
|
|
* or the maxElementSize of the caption if we include it
|
1998-04-14 00:24:54 +04:00
|
|
|
*/
|
1999-04-04 04:06:48 +04:00
|
|
|
if (aKidFrame == mCaptionFrame) {
|
1998-04-14 00:24:54 +04:00
|
|
|
if (nsnull != aMaxElementSize) {
|
|
|
|
aMaxElementSize->width = aKidMaxElementSize.width;
|
|
|
|
aMaxElementSize->height = aKidMaxElementSize.height;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-04-17 05:41:24 +04:00
|
|
|
NS_METHOD nsTableOuterFrame::VerifyTree() const
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
1998-04-17 05:41:24 +04:00
|
|
|
return NS_OK;
|
1998-04-14 00:24:54 +04:00
|
|
|
}
|
|
|
|
|
1998-04-17 02:21:32 +04:00
|
|
|
/**
|
|
|
|
* Remove and delete aChild's next-in-flow(s). Updates the sibling and flow
|
|
|
|
* pointers.
|
|
|
|
*
|
|
|
|
* Updates the child count and content offsets of all containers that are
|
|
|
|
* affected
|
|
|
|
*
|
|
|
|
* Overloaded here because nsContainerFrame makes assumptions about pseudo-frames
|
|
|
|
* that are not true for tables.
|
|
|
|
*
|
|
|
|
* @param aChild child this child's next-in-flow
|
|
|
|
* @return PR_TRUE if successful and PR_FALSE otherwise
|
|
|
|
*/
|
1999-04-04 04:06:48 +04:00
|
|
|
void nsTableOuterFrame::DeleteChildsNextInFlow(nsIPresContext& aPresContext,
|
|
|
|
nsIFrame* aChild)
|
1998-04-17 02:21:32 +04:00
|
|
|
{
|
1999-04-13 03:46:02 +04:00
|
|
|
NS_PRECONDITION(mFrames.ContainsFrame(aChild), "bad geometric parent");
|
1998-04-17 02:21:32 +04:00
|
|
|
|
1998-04-17 05:41:24 +04:00
|
|
|
nsIFrame* nextInFlow;
|
|
|
|
|
1999-02-24 07:48:08 +03:00
|
|
|
aChild->GetNextInFlow(&nextInFlow);
|
1998-04-17 05:41:24 +04:00
|
|
|
|
|
|
|
NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
|
|
|
|
nsTableOuterFrame* parent;
|
|
|
|
|
1999-02-10 04:36:30 +03:00
|
|
|
nextInFlow->GetParent((nsIFrame**)&parent);
|
1998-04-17 02:21:32 +04:00
|
|
|
|
|
|
|
// If the next-in-flow has a next-in-flow then delete it too (and
|
|
|
|
// delete it first).
|
1998-04-17 05:41:24 +04:00
|
|
|
nsIFrame* nextNextInFlow;
|
|
|
|
|
1999-02-24 07:48:08 +03:00
|
|
|
nextInFlow->GetNextInFlow(&nextNextInFlow);
|
1998-04-17 05:41:24 +04:00
|
|
|
if (nsnull != nextNextInFlow) {
|
1998-08-28 07:02:39 +04:00
|
|
|
parent->DeleteChildsNextInFlow(aPresContext, nextInFlow);
|
1998-04-17 02:21:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Disconnect the next-in-flow from the flow list
|
|
|
|
nextInFlow->BreakFromPrevFlow();
|
|
|
|
|
|
|
|
// Take the next-in-flow out of the parent's child list
|
1999-01-16 01:52:05 +03:00
|
|
|
if (parent->mFrames.FirstChild() == nextInFlow) {
|
|
|
|
nsIFrame* nextSibling;
|
1999-02-10 09:13:38 +03:00
|
|
|
nextInFlow->GetNextSibling(&nextSibling);
|
1999-01-16 01:52:05 +03:00
|
|
|
parent->mFrames.SetFrames(nextSibling);
|
1998-04-17 02:21:32 +04:00
|
|
|
|
|
|
|
} else {
|
1998-04-17 05:41:24 +04:00
|
|
|
nsIFrame* nextSibling;
|
|
|
|
|
1998-04-17 02:21:32 +04:00
|
|
|
// 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)
|
1999-02-10 09:13:38 +03:00
|
|
|
aChild->GetNextSibling(&nextSibling);
|
1998-04-17 05:41:24 +04:00
|
|
|
NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");
|
1998-04-17 02:21:32 +04:00
|
|
|
|
1999-02-10 09:13:38 +03:00
|
|
|
nextInFlow->GetNextSibling(&nextSibling);
|
1998-04-17 05:41:24 +04:00
|
|
|
aChild->SetNextSibling(nextSibling);
|
1998-04-17 02:21:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Delete the next-in-flow frame and adjust it's parent's child count
|
1999-07-22 06:24:52 +04:00
|
|
|
nextInFlow->Destroy(aPresContext);
|
1998-04-17 02:21:32 +04:00
|
|
|
|
1998-04-17 05:41:24 +04:00
|
|
|
#ifdef NS_DEBUG
|
1999-02-24 07:48:08 +03:00
|
|
|
aChild->GetNextInFlow(&nextInFlow);
|
1998-04-17 05:41:24 +04:00
|
|
|
NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
|
|
|
|
#endif
|
1998-04-17 02:21:32 +04:00
|
|
|
}
|
|
|
|
|
1999-02-24 08:54:31 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsTableOuterFrame::GetFrameType(nsIAtom** aType) const
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aType, "null OUT parameter pointer");
|
|
|
|
*aType = nsLayoutAtoms::tableOuterFrame;
|
|
|
|
NS_ADDREF(*aType);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-04-17 02:21:32 +04:00
|
|
|
|
1999-08-01 20:20:14 +04:00
|
|
|
/* ----- global methods ----- */
|
|
|
|
|
|
|
|
/*------------------ nsITableLayout methods ------------------------------*/
|
1999-08-01 02:11:50 +04:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsTableOuterFrame::GetCellDataAt(PRInt32 aRowIndex, PRInt32 aColIndex,
|
|
|
|
nsIDOMElement* &aCell, //out params
|
|
|
|
PRInt32& aStartRowIndex, PRInt32& aStartColIndex,
|
|
|
|
PRInt32& aRowSpan, PRInt32& aColSpan,
|
|
|
|
PRBool& aIsSelected)
|
|
|
|
{
|
|
|
|
if (!mInnerTableFrame) { return NS_ERROR_NOT_INITIALIZED; }
|
|
|
|
nsITableLayout *inner;
|
|
|
|
nsresult result = mInnerTableFrame->QueryInterface(nsITableLayout::GetIID(), (void **)&inner);
|
|
|
|
if (NS_SUCCEEDED(result) && inner)
|
|
|
|
{
|
|
|
|
return (inner->GetCellDataAt(aRowIndex, aColIndex, aCell,
|
|
|
|
aStartRowIndex, aStartColIndex,
|
|
|
|
aRowSpan, aColSpan, aIsSelected));
|
|
|
|
}
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
1999-08-01 20:20:14 +04:00
|
|
|
NS_IMETHODIMP nsTableOuterFrame::GetTableSize(PRInt32& aRowCount, PRInt32& aColCount)
|
|
|
|
{
|
|
|
|
if (!mInnerTableFrame) { return NS_ERROR_NOT_INITIALIZED; }
|
|
|
|
nsITableLayout *inner;
|
|
|
|
nsresult result = mInnerTableFrame->QueryInterface(nsITableLayout::GetIID(), (void **)&inner);
|
|
|
|
if (NS_SUCCEEDED(result) && inner)
|
|
|
|
{
|
|
|
|
return (inner->GetTableSize(aRowCount, aColCount));
|
|
|
|
}
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*---------------- end of nsITableLayout implementation ------------------*/
|
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1998-09-15 21:58:24 +04:00
|
|
|
nsresult
|
1999-05-12 02:03:29 +04:00
|
|
|
NS_NewTableOuterFrame(nsIFrame** aNewFrame)
|
1998-04-14 00:24:54 +04:00
|
|
|
{
|
1999-05-12 02:03:29 +04:00
|
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
|
|
if (nsnull == aNewFrame) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
nsTableOuterFrame* it = new nsTableOuterFrame;
|
1998-04-14 00:24:54 +04:00
|
|
|
if (nsnull == it) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
1999-05-12 02:03:29 +04:00
|
|
|
*aNewFrame = it;
|
1998-04-14 00:24:54 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
1998-09-03 01:59:54 +04:00
|
|
|
|
1998-11-19 20:22:29 +03:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsTableOuterFrame::GetFrameName(nsString& aResult) const
|
|
|
|
{
|
|
|
|
return MakeFrameName("TableOuter", aResult);
|
|
|
|
}
|