mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-06-03 06:10:13 +02:00
1599 lines
60 KiB
C++
1599 lines
60 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
#include "nsTableRowFrame.h"
|
|
#include "nsTableRowGroupFrame.h"
|
|
#include "nsIRenderingContext.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsStyleContext.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsHTMLAtoms.h"
|
|
#include "nsIContent.h"
|
|
#include "nsTableFrame.h"
|
|
#include "nsTableCellFrame.h"
|
|
#include "nsIView.h"
|
|
#include "nsReflowPath.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsLayoutAtoms.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsTableColGroupFrame.h"
|
|
#include "nsTableColFrame.h"
|
|
#include "nsCOMPtr.h"
|
|
|
|
|
|
struct nsTableCellReflowState : public nsHTMLReflowState
|
|
{
|
|
nsTableCellReflowState(nsPresContext* aPresContext,
|
|
const nsHTMLReflowState& aParentReflowState,
|
|
nsIFrame* aFrame,
|
|
const nsSize& aAvailableSpace,
|
|
nsReflowReason aReason);
|
|
|
|
void FixUp(const nsSize& aAvailSpace,
|
|
PRBool aResetComputedWidth);
|
|
};
|
|
|
|
nsTableCellReflowState::nsTableCellReflowState(nsPresContext* aPresContext,
|
|
const nsHTMLReflowState& aParentRS,
|
|
nsIFrame* aFrame,
|
|
const nsSize& aAvailSpace,
|
|
nsReflowReason aReason)
|
|
:nsHTMLReflowState(aPresContext, aParentRS, aFrame, aAvailSpace, aReason)
|
|
{
|
|
}
|
|
|
|
void nsTableCellReflowState::FixUp(const nsSize& aAvailSpace,
|
|
PRBool aResetComputedWidth)
|
|
{
|
|
// fix the mComputed values during a pass 2 reflow since the cell can be a percentage base
|
|
if (NS_UNCONSTRAINEDSIZE != aAvailSpace.width) {
|
|
if (aResetComputedWidth) {
|
|
mComputedWidth = NS_UNCONSTRAINEDSIZE;
|
|
}
|
|
else if (NS_UNCONSTRAINEDSIZE != mComputedWidth) {
|
|
mComputedWidth = aAvailSpace.width - mComputedBorderPadding.left - mComputedBorderPadding.right;
|
|
mComputedWidth = PR_MAX(0, mComputedWidth);
|
|
}
|
|
if (NS_UNCONSTRAINEDSIZE != mComputedHeight) {
|
|
if (NS_UNCONSTRAINEDSIZE != aAvailSpace.height) {
|
|
mComputedHeight = aAvailSpace.height - mComputedBorderPadding.top - mComputedBorderPadding.bottom;
|
|
mComputedHeight = PR_MAX(0, mComputedHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::InitChildReflowState(nsPresContext& aPresContext,
|
|
const nsSize& aAvailSize,
|
|
PRBool aBorderCollapse,
|
|
float aPixelsToTwips,
|
|
nsTableCellReflowState& aReflowState,
|
|
PRBool aResetComputedWidth)
|
|
{
|
|
nsMargin collapseBorder;
|
|
nsMargin* pCollapseBorder = nsnull;
|
|
if (aBorderCollapse) {
|
|
// we only reflow cells, so don't need to check frame type
|
|
nsBCTableCellFrame* bcCellFrame = (nsBCTableCellFrame*)aReflowState.frame;
|
|
if (bcCellFrame) {
|
|
pCollapseBorder = bcCellFrame->GetBorderWidth(aPixelsToTwips, collapseBorder);
|
|
}
|
|
}
|
|
aReflowState.Init(&aPresContext, -1, -1, pCollapseBorder);
|
|
aReflowState.FixUp(aAvailSize, aResetComputedWidth);
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::SetFixedHeight(nscoord aValue)
|
|
{
|
|
nscoord height = PR_MAX(0, aValue);
|
|
if (HasFixedHeight()) {
|
|
if (height > mStyleFixedHeight) {
|
|
mStyleFixedHeight = height;
|
|
}
|
|
}
|
|
else {
|
|
mStyleFixedHeight = height;
|
|
if (height > 0) {
|
|
SetHasFixedHeight(PR_TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::SetPctHeight(float aPctValue,
|
|
PRBool aForce)
|
|
{
|
|
nscoord height = PR_MAX(0, NSToCoordRound(aPctValue * 100.0f));
|
|
if (HasPctHeight()) {
|
|
if ((height > mStylePctHeight) || aForce) {
|
|
mStylePctHeight = height;
|
|
}
|
|
}
|
|
else {
|
|
mStylePctHeight = height;
|
|
if (height > 0.0f) {
|
|
SetHasPctHeight(PR_TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 'old' is old cached cell's desired size
|
|
// 'new' is new cell's size including style constraints
|
|
static PRBool
|
|
TallestCellGotShorter(nscoord aOld,
|
|
nscoord aNew,
|
|
nscoord aTallest)
|
|
{
|
|
return ((aNew < aOld) && (aOld == aTallest));
|
|
}
|
|
|
|
/* ----------- nsTableRowFrame ---------- */
|
|
|
|
nsTableRowFrame::nsTableRowFrame()
|
|
: nsHTMLContainerFrame()
|
|
{
|
|
mBits.mRowIndex = mBits.mFirstInserted = 0;
|
|
ResetHeight(0);
|
|
#ifdef DEBUG_TABLE_REFLOW_TIMING
|
|
mTimer = new nsReflowTimer(this);
|
|
#endif
|
|
}
|
|
|
|
nsTableRowFrame::~nsTableRowFrame()
|
|
{
|
|
#ifdef DEBUG_TABLE_REFLOW_TIMING
|
|
nsTableFrame::DebugReflowDone(this);
|
|
#endif
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsTableRowFrame::Init(nsPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParent,
|
|
nsStyleContext* aContext,
|
|
nsIFrame* aPrevInFlow)
|
|
{
|
|
nsresult rv;
|
|
|
|
// Let the the base class do its initialization
|
|
rv = nsHTMLContainerFrame::Init(aPresContext, aContent, aParent, aContext,
|
|
aPrevInFlow);
|
|
|
|
// record that children that are ignorable whitespace should be excluded
|
|
mState |= NS_FRAME_EXCLUDE_IGNORABLE_WHITESPACE;
|
|
|
|
if (aPrevInFlow) {
|
|
// Set the row index
|
|
nsTableRowFrame* rowFrame = (nsTableRowFrame*)aPrevInFlow;
|
|
|
|
SetRowIndex(rowFrame->GetRowIndex());
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsTableRowFrame::AppendFrames(nsIAtom* aListName,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
// Append the frames
|
|
mFrames.AppendFrames(nsnull, aFrameList);
|
|
|
|
// Add the new cell frames to the table
|
|
nsTableFrame *tableFrame = nsnull;
|
|
nsTableFrame::GetTableFrame(this, tableFrame);
|
|
for (nsIFrame* childFrame = aFrameList; childFrame;
|
|
childFrame = childFrame->GetNextSibling()) {
|
|
if (IS_TABLE_CELL(childFrame->GetType())) {
|
|
// Add the cell to the cell map
|
|
tableFrame->AppendCell((nsTableCellFrame&)*childFrame, GetRowIndex());
|
|
// XXX this could be optimized with some effort
|
|
tableFrame->SetNeedStrategyInit(PR_TRUE);
|
|
}
|
|
}
|
|
|
|
// Reflow the new frames. They're already marked dirty, so generate a reflow
|
|
// command that tells us to reflow our dirty child frames
|
|
tableFrame->AppendDirtyReflowCommand(this);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsTableRowFrame::InsertFrames(nsIAtom* aListName,
|
|
nsIFrame* aPrevFrame,
|
|
nsIFrame* aFrameList)
|
|
{
|
|
// Get the table frame
|
|
nsTableFrame* tableFrame = nsnull;
|
|
nsTableFrame::GetTableFrame(this, tableFrame);
|
|
|
|
// gather the new frames (only those which are cells) into an array
|
|
nsIAtom* cellFrameType = (tableFrame->IsBorderCollapse()) ? nsLayoutAtoms::bcTableCellFrame : nsLayoutAtoms::tableCellFrame;
|
|
nsTableCellFrame* prevCellFrame = (nsTableCellFrame *)nsTableFrame::GetFrameAtOrBefore(this, aPrevFrame, cellFrameType);
|
|
nsVoidArray cellChildren;
|
|
for (nsIFrame* childFrame = aFrameList; childFrame;
|
|
childFrame = childFrame->GetNextSibling()) {
|
|
if (IS_TABLE_CELL(childFrame->GetType())) {
|
|
cellChildren.AppendElement(childFrame);
|
|
// XXX this could be optimized with some effort
|
|
tableFrame->SetNeedStrategyInit(PR_TRUE);
|
|
}
|
|
}
|
|
// insert the cells into the cell map
|
|
PRInt32 colIndex = -1;
|
|
if (prevCellFrame) {
|
|
prevCellFrame->GetColIndex(colIndex);
|
|
}
|
|
tableFrame->InsertCells(cellChildren, GetRowIndex(), colIndex);
|
|
|
|
// Insert the frames in the frame list
|
|
mFrames.InsertFrames(nsnull, aPrevFrame, aFrameList);
|
|
|
|
// Reflow the new frames. They're already marked dirty, so generate a reflow
|
|
// command that tells us to reflow our dirty child frames
|
|
tableFrame->AppendDirtyReflowCommand(this);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsTableRowFrame::RemoveFrame(nsIAtom* aListName,
|
|
nsIFrame* aOldFrame)
|
|
{
|
|
// Get the table frame
|
|
nsTableFrame* tableFrame=nsnull;
|
|
nsTableFrame::GetTableFrame(this, tableFrame);
|
|
if (tableFrame) {
|
|
if (IS_TABLE_CELL(aOldFrame->GetType())) {
|
|
nsTableCellFrame* cellFrame = (nsTableCellFrame*)aOldFrame;
|
|
PRInt32 colIndex;
|
|
cellFrame->GetColIndex(colIndex);
|
|
// remove the cell from the cell map
|
|
tableFrame->RemoveCell(cellFrame, GetRowIndex());
|
|
// XXX this could be optimized with some effort
|
|
tableFrame->SetNeedStrategyInit(PR_TRUE);
|
|
|
|
// Remove the frame and destroy it
|
|
mFrames.DestroyFrame(GetPresContext(), aOldFrame);
|
|
|
|
// XXX This could probably be optimized with much effort
|
|
tableFrame->SetNeedStrategyInit(PR_TRUE);
|
|
// Generate a reflow command so we reflow the table itself.
|
|
// Target the row so that it gets a dirty reflow before a resize reflow
|
|
// in case another cell gets added to the row during a reflow coallesce.
|
|
tableFrame->AppendDirtyReflowCommand(this);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nscoord
|
|
GetHeightOfRowsSpannedBelowFirst(nsTableCellFrame& aTableCellFrame,
|
|
nsTableFrame& aTableFrame)
|
|
{
|
|
nscoord height = 0;
|
|
nscoord cellSpacingY = aTableFrame.GetCellSpacingY();
|
|
PRInt32 rowSpan = aTableFrame.GetEffectiveRowSpan(aTableCellFrame);
|
|
// add in height of rows spanned beyond the 1st one
|
|
nsIFrame* nextRow = aTableCellFrame.GetParent()->GetNextSibling();
|
|
for (PRInt32 rowX = 1; ((rowX < rowSpan) && nextRow);) {
|
|
if (nsLayoutAtoms::tableRowFrame == nextRow->GetType()) {
|
|
height += nextRow->GetSize().height;
|
|
rowX++;
|
|
}
|
|
height += cellSpacingY;
|
|
nextRow = nextRow->GetNextSibling();
|
|
}
|
|
return height;
|
|
}
|
|
|
|
nsTableCellFrame*
|
|
nsTableRowFrame::GetFirstCell()
|
|
{
|
|
nsIFrame* childFrame = mFrames.FirstChild();
|
|
while (childFrame) {
|
|
if (IS_TABLE_CELL(childFrame->GetType())) {
|
|
return (nsTableCellFrame*)childFrame;
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
return nsnull;
|
|
}
|
|
|
|
/**
|
|
* Post-reflow hook. This is where the table row does its post-processing
|
|
*/
|
|
void
|
|
nsTableRowFrame::DidResize(nsPresContext* aPresContext,
|
|
const nsHTMLReflowState& aReflowState)
|
|
{
|
|
// Resize and re-align the cell frames based on our row height
|
|
nsTableFrame* tableFrame;
|
|
nsTableFrame::GetTableFrame(this, tableFrame);
|
|
if (!tableFrame) return;
|
|
|
|
nsTableIterator iter(*this, eTableDIR);
|
|
nsIFrame* childFrame = iter.First();
|
|
|
|
nsHTMLReflowMetrics desiredSize(PR_FALSE);
|
|
desiredSize.width = mRect.width;
|
|
desiredSize.height = mRect.height;
|
|
desiredSize.mOverflowArea = nsRect(0, 0, desiredSize.width,
|
|
desiredSize.height);
|
|
|
|
while (childFrame) {
|
|
if (IS_TABLE_CELL(childFrame->GetType())) {
|
|
nsTableCellFrame* cellFrame = (nsTableCellFrame*)childFrame;
|
|
nscoord cellHeight = mRect.height + GetHeightOfRowsSpannedBelowFirst(*cellFrame, *tableFrame);
|
|
|
|
// resize the cell's height
|
|
//if (cellFrameSize.height!=cellHeight)
|
|
{
|
|
// XXX If the cell frame has a view, then we need to resize
|
|
// it as well. We would like to only do that if the cell's size
|
|
// is changing. Why is the 'if' stmt above commented out?
|
|
cellFrame->SetSize(nsSize(cellFrame->GetSize().width, cellHeight));
|
|
// realign cell content based on the new height
|
|
/*nsHTMLReflowMetrics desiredSize(nsnull);
|
|
nsHTMLReflowState kidReflowState(aPresContext, aReflowState,
|
|
cellFrame,
|
|
nsSize(cellFrameSize.width, cellHeight),
|
|
eReflowReason_Resize);*/
|
|
//XXX: the following reflow is necessary for any content of the cell
|
|
// whose height is a percent of the cell's height (maybe indirectly.)
|
|
// But some content crashes when this reflow is issued, to be investigated
|
|
//XXX nsReflowStatus status;
|
|
//ReflowChild(cellFrame, aPresContext, desiredSize, kidReflowState, status);
|
|
|
|
cellFrame->VerticallyAlignChild(aReflowState, mMaxCellAscent);
|
|
ConsiderChildOverflow(desiredSize.mOverflowArea, cellFrame);
|
|
}
|
|
}
|
|
// Get the next child
|
|
childFrame = iter.Next();
|
|
}
|
|
FinishAndStoreOverflow(&desiredSize);
|
|
if (HasView()) {
|
|
nsContainerFrame::SyncFrameViewAfterReflow(aPresContext, this, GetView(), &desiredSize.mOverflowArea, 0);
|
|
}
|
|
// Let our base class do the usual work
|
|
}
|
|
|
|
// returns max-ascent amongst all cells that have 'vertical-align: baseline'
|
|
// *including* cells with rowspans
|
|
nscoord nsTableRowFrame::GetMaxCellAscent() const
|
|
{
|
|
return mMaxCellAscent;
|
|
}
|
|
|
|
nscoord
|
|
nsTableRowFrame::GetHeight(nscoord aPctBasis) const
|
|
{
|
|
nscoord height = 0;
|
|
if ((aPctBasis > 0) && HasPctHeight()) {
|
|
height = NSToCoordRound(GetPctHeight() * (float)aPctBasis);
|
|
}
|
|
if (HasFixedHeight()) {
|
|
height = PR_MAX(height, GetFixedHeight());
|
|
}
|
|
return PR_MAX(height, GetContentHeight());
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::ResetHeight(nscoord aFixedHeight)
|
|
{
|
|
SetHasFixedHeight(PR_FALSE);
|
|
SetHasPctHeight(PR_FALSE);
|
|
SetFixedHeight(0);
|
|
SetPctHeight(0);
|
|
SetContentHeight(0);
|
|
|
|
if (aFixedHeight > 0) {
|
|
SetFixedHeight(aFixedHeight);
|
|
}
|
|
|
|
mMaxCellAscent = 0;
|
|
mMaxCellDescent = 0;
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::UpdateHeight(nscoord aHeight,
|
|
nscoord aAscent,
|
|
nscoord aDescent,
|
|
nsTableFrame* aTableFrame,
|
|
nsTableCellFrame* aCellFrame)
|
|
{
|
|
if (!aTableFrame || !aCellFrame) {
|
|
NS_ASSERTION(PR_FALSE , "invalid call");
|
|
return;
|
|
}
|
|
|
|
if (aHeight != NS_UNCONSTRAINEDSIZE) {
|
|
if (!(aCellFrame->HasVerticalAlignBaseline())) { // only the cell's height matters
|
|
if (GetHeight() < aHeight) {
|
|
PRInt32 rowSpan = aTableFrame->GetEffectiveRowSpan(*aCellFrame);
|
|
if (rowSpan == 1) {
|
|
SetContentHeight(aHeight);
|
|
}
|
|
}
|
|
}
|
|
else { // the alignment on the baseline can change the height
|
|
NS_ASSERTION((aAscent != NS_UNCONSTRAINEDSIZE) && (aDescent != NS_UNCONSTRAINEDSIZE), "invalid call");
|
|
// see if this is a long ascender
|
|
if (mMaxCellAscent < aAscent) {
|
|
mMaxCellAscent = aAscent;
|
|
}
|
|
// see if this is a long descender and without rowspan
|
|
if (mMaxCellDescent < aDescent) {
|
|
PRInt32 rowSpan = aTableFrame->GetEffectiveRowSpan(*aCellFrame);
|
|
if (rowSpan == 1) {
|
|
mMaxCellDescent = aDescent;
|
|
}
|
|
}
|
|
// keep the tallest height in sync
|
|
if (GetHeight() < mMaxCellAscent + mMaxCellDescent) {
|
|
SetContentHeight(mMaxCellAscent + mMaxCellDescent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
nscoord
|
|
nsTableRowFrame::CalcHeight(const nsHTMLReflowState& aReflowState)
|
|
{
|
|
nsTableFrame* tableFrame = nsnull;
|
|
nsTableFrame::GetTableFrame(this, tableFrame);
|
|
if (!tableFrame) return 0;
|
|
|
|
nscoord computedHeight = (NS_UNCONSTRAINEDSIZE == aReflowState.mComputedHeight)
|
|
? 0 : aReflowState.mComputedHeight;
|
|
ResetHeight(computedHeight);
|
|
|
|
const nsStylePosition* position = GetStylePosition();
|
|
if (eStyleUnit_Coord == position->mHeight.GetUnit()) {
|
|
SetFixedHeight(position->mHeight.GetCoordValue());
|
|
}
|
|
else if (eStyleUnit_Percent == position->mHeight.GetUnit()) {
|
|
SetPctHeight(position->mHeight.GetPercentValue());
|
|
}
|
|
|
|
for (nsIFrame* kidFrame = mFrames.FirstChild(); kidFrame;
|
|
kidFrame = kidFrame->GetNextSibling()) {
|
|
if (IS_TABLE_CELL(kidFrame->GetType())) {
|
|
nscoord availWidth = ((nsTableCellFrame *)kidFrame)->GetPriorAvailWidth();
|
|
nsSize desSize = ((nsTableCellFrame *)kidFrame)->GetDesiredSize();
|
|
if ((NS_UNCONSTRAINEDSIZE == aReflowState.availableHeight) && !mPrevInFlow) {
|
|
CalculateCellActualSize(kidFrame, desSize.width, desSize.height, availWidth);
|
|
}
|
|
// height may have changed, adjust descent to absorb any excess difference
|
|
nscoord ascent = ((nsTableCellFrame *)kidFrame)->GetDesiredAscent();
|
|
nscoord descent = desSize.height - ascent;
|
|
UpdateHeight(desSize.height, ascent, descent, tableFrame, (nsTableCellFrame*)kidFrame);
|
|
}
|
|
}
|
|
return GetHeight();
|
|
}
|
|
|
|
NS_METHOD nsTableRowFrame::Paint(nsPresContext* aPresContext,
|
|
nsIRenderingContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsFramePaintLayer aWhichLayer,
|
|
PRUint32 aFlags)
|
|
{
|
|
PRBool isVisible;
|
|
if (NS_SUCCEEDED(IsVisibleForPainting(aPresContext, aRenderingContext, PR_FALSE, &isVisible)) && !isVisible) {
|
|
return NS_OK;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// for debug...
|
|
if ((NS_FRAME_PAINT_LAYER_DEBUG == aWhichLayer) && GetShowFrameBorders()) {
|
|
aRenderingContext.SetColor(NS_RGB(0,255,0));
|
|
aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
|
|
}
|
|
#endif
|
|
|
|
if (NS_FRAME_PAINT_LAYER_BACKGROUND == aWhichLayer &&
|
|
//direct (not table-called) background paint
|
|
!(aFlags & (NS_PAINT_FLAG_TABLE_BG_PAINT | NS_PAINT_FLAG_TABLE_CELL_BG_PASS))) {
|
|
nsTableFrame* tableFrame;
|
|
nsTableFrame::GetTableFrame(this, tableFrame);
|
|
NS_ASSERTION(tableFrame, "null table frame");
|
|
|
|
TableBackgroundPainter painter(tableFrame,
|
|
TableBackgroundPainter::eOrigin_TableRow,
|
|
aPresContext, aRenderingContext,
|
|
aDirtyRect);
|
|
nsresult rv = painter.PaintRow(this);
|
|
if (NS_FAILED(rv)) return rv;
|
|
aFlags |= NS_PAINT_FLAG_TABLE_BG_PAINT;
|
|
}
|
|
|
|
PRBool clip = GetStyleDisplay()->IsTableClip();
|
|
if (clip) {
|
|
aRenderingContext.PushState();
|
|
SetOverflowClipRect(aRenderingContext);
|
|
}
|
|
PaintChildren(aPresContext, aRenderingContext, aDirtyRect,
|
|
aWhichLayer, aFlags);
|
|
|
|
// Paint outline
|
|
nsRect rect(0, 0, mRect.width, mRect.height);
|
|
const nsStyleOutline* outlineStyle = GetStyleOutline();
|
|
const nsStyleBorder* borderStyle = GetStyleBorder();
|
|
nsCSSRendering::PaintOutline(aPresContext, aRenderingContext, this,
|
|
aDirtyRect, rect, *borderStyle, *outlineStyle,
|
|
mStyleContext, 0);
|
|
if (clip)
|
|
aRenderingContext.PopState();
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
PRIntn
|
|
nsTableRowFrame::GetSkipSides() const
|
|
{
|
|
PRIntn skip = 0;
|
|
if (nsnull != mPrevInFlow) {
|
|
skip |= 1 << NS_SIDE_TOP;
|
|
}
|
|
if (nsnull != mNextInFlow) {
|
|
skip |= 1 << NS_SIDE_BOTTOM;
|
|
}
|
|
return skip;
|
|
}
|
|
|
|
|
|
/* we overload this here because rows have children that can span outside of themselves.
|
|
* so the default "get the child rect, see if it contains the event point" action isn't
|
|
* sufficient. We have to ask the row if it has a child that contains the point.
|
|
*/
|
|
NS_IMETHODIMP
|
|
nsTableRowFrame::GetFrameForPoint(const nsPoint& aPoint,
|
|
nsFramePaintLayer aWhichLayer,
|
|
nsIFrame** aFrame)
|
|
{
|
|
// XXX This would not need to exist (except as a one-liner, to make this
|
|
// frame work like a block frame) if rows with rowspan cells made the
|
|
// the NS_FRAME_OUTSIDE_CHILDREN bit of mState set correctly (see
|
|
// nsIFrame.h).
|
|
|
|
// XXXldb Do we need this anymore?
|
|
|
|
// I imagine fixing this would help performance of GetFrameForPoint in
|
|
// tables. It may also fix problems with relative positioning.
|
|
|
|
// This is basically copied from nsContainerFrame::GetFrameForPointUsing,
|
|
// except for one bit removed
|
|
|
|
nsIFrame *hit;
|
|
nsPoint tmp;
|
|
|
|
nsIFrame* kid = GetFirstChild(nsnull);
|
|
*aFrame = nsnull;
|
|
tmp.MoveTo(aPoint.x - mRect.x, aPoint.y - mRect.y);
|
|
while (nsnull != kid) {
|
|
nsresult rv = kid->GetFrameForPoint(tmp, aWhichLayer, &hit);
|
|
|
|
if (NS_SUCCEEDED(rv) && hit) {
|
|
*aFrame = hit;
|
|
}
|
|
kid = kid->GetNextSibling();
|
|
}
|
|
|
|
if (*aFrame) {
|
|
return NS_OK;
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Calculate the cell's actual size given its pass2 desired width and height.
|
|
// Takes into account the specified height (in the style), and any special logic
|
|
// needed for backwards compatibility.
|
|
// Modifies the desired width and height that are passed in.
|
|
nsresult
|
|
nsTableRowFrame::CalculateCellActualSize(nsIFrame* aCellFrame,
|
|
nscoord& aDesiredWidth,
|
|
nscoord& aDesiredHeight,
|
|
nscoord aAvailWidth)
|
|
{
|
|
nscoord specifiedHeight = 0;
|
|
|
|
// Get the height specified in the style information
|
|
const nsStylePosition* position = aCellFrame->GetStylePosition();
|
|
|
|
nsTableFrame* tableFrame = nsnull;
|
|
nsTableFrame::GetTableFrame(this, tableFrame);
|
|
if (!tableFrame) return NS_ERROR_NULL_POINTER;
|
|
|
|
PRInt32 rowSpan = tableFrame->GetEffectiveRowSpan((nsTableCellFrame&)*aCellFrame);
|
|
|
|
switch (position->mHeight.GetUnit()) {
|
|
case eStyleUnit_Coord:
|
|
specifiedHeight = position->mHeight.GetCoordValue();
|
|
if (1 == rowSpan)
|
|
SetFixedHeight(specifiedHeight);
|
|
break;
|
|
case eStyleUnit_Percent: {
|
|
if (1 == rowSpan)
|
|
SetPctHeight(position->mHeight.GetPercentValue());
|
|
// pct heights are handled when all of the cells are finished, so don't set specifiedHeight
|
|
break;
|
|
}
|
|
case eStyleUnit_Auto:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// If the specified height is greater than the desired height, then use the specified height
|
|
if (specifiedHeight > aDesiredHeight)
|
|
aDesiredHeight = specifiedHeight;
|
|
|
|
if ((0 == aDesiredWidth) && (NS_UNCONSTRAINEDSIZE != aAvailWidth)) { // special Nav4 compatibility code for the width
|
|
aDesiredWidth = aAvailWidth;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Calculates the available width for the table cell based on the known
|
|
// column widths taking into account column spans and column spacing
|
|
static void
|
|
CalcAvailWidth(nsTableFrame& aTableFrame,
|
|
nscoord aTableComputedWidth,
|
|
float aPixelToTwips,
|
|
nsTableCellFrame& aCellFrame,
|
|
nscoord aCellSpacingX,
|
|
nscoord& aColAvailWidth,
|
|
nscoord& aCellAvailWidth)
|
|
{
|
|
aColAvailWidth = aCellAvailWidth = NS_UNCONSTRAINEDSIZE;
|
|
PRInt32 colIndex;
|
|
aCellFrame.GetColIndex(colIndex);
|
|
PRInt32 colspan = aTableFrame.GetEffectiveColSpan(aCellFrame);
|
|
nscoord cellSpacing = 0;
|
|
|
|
for (PRInt32 spanX = 0; spanX < colspan; spanX++) {
|
|
nscoord colWidth = aTableFrame.GetColumnWidth(colIndex + spanX);
|
|
if (colWidth != WIDTH_NOT_SET) {
|
|
if (NS_UNCONSTRAINEDSIZE == aColAvailWidth) {
|
|
aColAvailWidth = colWidth;
|
|
}
|
|
else {
|
|
aColAvailWidth += colWidth;
|
|
}
|
|
}
|
|
if ((spanX > 0) && (aTableFrame.GetNumCellsOriginatingInCol(colIndex + spanX) > 0)) {
|
|
cellSpacing += aCellSpacingX;
|
|
}
|
|
}
|
|
if (NS_UNCONSTRAINEDSIZE != aColAvailWidth) {
|
|
aColAvailWidth += cellSpacing;
|
|
}
|
|
aCellAvailWidth = aColAvailWidth;
|
|
|
|
// for a cell with a colspan > 1, use its fix width (if set) as the avail width
|
|
// if this is its initial reflow
|
|
if ((aCellFrame.GetStateBits() & NS_FRAME_FIRST_REFLOW)
|
|
&& (aTableFrame.GetEffectiveColSpan(aCellFrame) > 1)) {
|
|
// see if the cell has a style width specified
|
|
const nsStylePosition* cellPosition = aCellFrame.GetStylePosition();
|
|
if (eStyleUnit_Coord == cellPosition->mWidth.GetUnit()) {
|
|
// need to add padding into fixed width
|
|
nsMargin borderPadding(0,0,0,0);
|
|
if (NS_UNCONSTRAINEDSIZE != aTableComputedWidth) {
|
|
borderPadding = nsTableFrame::GetBorderPadding(nsSize(aTableComputedWidth, 0),
|
|
aPixelToTwips, &aCellFrame);
|
|
}
|
|
nscoord fixWidth = cellPosition->mWidth.GetCoordValue() + borderPadding.left + borderPadding.right;
|
|
if (NS_UNCONSTRAINEDSIZE != aColAvailWidth) {
|
|
aCellAvailWidth = PR_MIN(aColAvailWidth, fixWidth);
|
|
} else {
|
|
aCellAvailWidth = fixWidth;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
nscoord
|
|
GetSpaceBetween(PRInt32 aPrevColIndex,
|
|
PRInt32 aColIndex,
|
|
PRInt32 aColSpan,
|
|
nsTableFrame& aTableFrame,
|
|
nscoord aCellSpacingX,
|
|
PRBool aIsLeftToRight)
|
|
{
|
|
nscoord space = 0;
|
|
PRInt32 colX;
|
|
if (aIsLeftToRight) {
|
|
for (colX = aPrevColIndex + 1; aColIndex > colX; colX++) {
|
|
space += aTableFrame.GetColumnWidth(colX);
|
|
if (aTableFrame.GetNumCellsOriginatingInCol(colX) > 0) {
|
|
space += aCellSpacingX;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
PRInt32 lastCol = aColIndex + aColSpan - 1;
|
|
for (colX = aPrevColIndex - 1; colX > lastCol; colX--) {
|
|
space += aTableFrame.GetColumnWidth(colX);
|
|
if (aTableFrame.GetNumCellsOriginatingInCol(colX) > 0) {
|
|
space += aCellSpacingX;
|
|
}
|
|
}
|
|
}
|
|
return space;
|
|
}
|
|
|
|
static nscoord
|
|
GetComputedWidth(const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame)
|
|
{
|
|
const nsHTMLReflowState* parentReflow = aReflowState.parentReflowState;
|
|
nscoord computedWidth = 0;
|
|
while (parentReflow) {
|
|
if (parentReflow->frame == &aTableFrame) {
|
|
computedWidth = parentReflow->mComputedWidth;
|
|
break;
|
|
}
|
|
parentReflow = parentReflow->parentReflowState;
|
|
}
|
|
return computedWidth;
|
|
}
|
|
|
|
// subtract the heights of aRow's prev in flows from the unpaginated height
|
|
static
|
|
nscoord CalcHeightFromUnpaginatedHeight(nsPresContext* aPresContext,
|
|
nsTableRowFrame& aRow)
|
|
{
|
|
nscoord height = 0;
|
|
nsTableRowFrame* firstInFlow = (nsTableRowFrame*)aRow.GetFirstInFlow();
|
|
if (!firstInFlow) ABORT1(0);
|
|
if (firstInFlow->HasUnpaginatedHeight()) {
|
|
height = firstInFlow->GetUnpaginatedHeight(aPresContext);
|
|
for (nsIFrame* prevInFlow = aRow.GetPrevInFlow(); prevInFlow;
|
|
prevInFlow = prevInFlow->GetPrevInFlow()) {
|
|
height -= prevInFlow->GetSize().height;
|
|
}
|
|
}
|
|
return PR_MAX(height, 0);
|
|
}
|
|
|
|
// Called for a dirty or resize reflow. Reflows all the existing table cell
|
|
// frames unless aDirtyOnly is PR_TRUE in which case only reflow the dirty frames
|
|
|
|
NS_METHOD
|
|
nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame,
|
|
nsReflowStatus& aStatus,
|
|
PRBool aDirtyOnly)
|
|
{
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
|
|
GET_PIXELS_TO_TWIPS(aPresContext, p2t);
|
|
PRBool borderCollapse = (((nsTableFrame*)aTableFrame.GetFirstInFlow())->IsBorderCollapse());
|
|
|
|
nsIFrame* tablePrevInFlow = aTableFrame.GetPrevInFlow();
|
|
PRBool isPaginated = aPresContext->IsPaginated();
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nscoord cellSpacingX = aTableFrame.GetCellSpacingX();
|
|
PRInt32 cellColSpan = 1; // must be defined here so it's set properly for non-cell kids
|
|
|
|
nsTableIteration dir = (aReflowState.availableWidth == NS_UNCONSTRAINEDSIZE)
|
|
? eTableLTR : eTableDIR;
|
|
nsTableIterator iter(*this, dir);
|
|
// remember the col index of the previous cell to handle rowspans into this row
|
|
PRInt32 firstPrevColIndex = (iter.IsLeftToRight()) ? -1 : aTableFrame.GetColCount();
|
|
PRInt32 prevColIndex = firstPrevColIndex;
|
|
nscoord x = 0; // running total of children x offset
|
|
|
|
PRBool isAutoLayout = aTableFrame.IsAutoLayout();
|
|
PRBool needToNotifyTable = PR_TRUE;
|
|
nscoord paginatedHeight = 0;
|
|
// If the incremental reflow command is a StyleChanged reflow and
|
|
// it's target is the current frame, then make sure we send
|
|
// StyleChange reflow reasons down to the children so that they
|
|
// don't over-optimize their reflow.
|
|
|
|
PRBool notifyStyleChange = PR_FALSE;
|
|
if (eReflowReason_Incremental == aReflowState.reason) {
|
|
nsHTMLReflowCommand* command = aReflowState.path->mReflowCommand;
|
|
if (command) {
|
|
nsReflowType type;
|
|
command->GetType(type);
|
|
if (eReflowType_StyleChanged == type) {
|
|
notifyStyleChange = PR_TRUE;
|
|
}
|
|
}
|
|
}
|
|
// Reflow each of our existing cell frames
|
|
nsIFrame* kidFrame = iter.First();
|
|
while (kidFrame) {
|
|
nsIAtom* frameType = kidFrame->GetType();
|
|
|
|
// See if we should only reflow the dirty child frames
|
|
PRBool doReflowChild = PR_TRUE;
|
|
if (aDirtyOnly && ((kidFrame->GetStateBits() & NS_FRAME_IS_DIRTY) == 0)) {
|
|
doReflowChild = PR_FALSE;
|
|
}
|
|
else if ((NS_UNCONSTRAINEDSIZE != aReflowState.availableHeight) && IS_TABLE_CELL(frameType)) {
|
|
// We don't reflow a rowspan >1 cell here with a constrained height.
|
|
// That happens in nsTableRowGroupFrame::SplitSpanningCells.
|
|
if (aTableFrame.GetEffectiveRowSpan((nsTableCellFrame&)*kidFrame) > 1) {
|
|
doReflowChild = PR_FALSE;
|
|
}
|
|
}
|
|
if (aReflowState.mFlags.mSpecialHeightReflow) {
|
|
if (!isPaginated && (IS_TABLE_CELL(frameType) &&
|
|
!((nsTableCellFrame*)kidFrame)->NeedSpecialReflow())) {
|
|
kidFrame = iter.Next();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Reflow the child frame
|
|
if (doReflowChild) {
|
|
if (IS_TABLE_CELL(frameType)) {
|
|
nsTableCellFrame* cellFrame = (nsTableCellFrame*)kidFrame;
|
|
PRInt32 cellColIndex;
|
|
cellFrame->GetColIndex(cellColIndex);
|
|
cellColSpan = aTableFrame.GetEffectiveColSpan(*cellFrame);
|
|
|
|
// If the adjacent cell is in a prior row (because of a rowspan) add in the space
|
|
if ((iter.IsLeftToRight() && (prevColIndex != (cellColIndex - 1))) ||
|
|
(!iter.IsLeftToRight() && (prevColIndex != cellColIndex + cellColSpan))) {
|
|
x += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan, aTableFrame,
|
|
cellSpacingX, iter.IsLeftToRight());
|
|
}
|
|
// Calculate the available width for the table cell using the known column widths
|
|
nscoord availColWidth, availCellWidth;
|
|
CalcAvailWidth(aTableFrame, GetComputedWidth(aReflowState, aTableFrame), p2t,
|
|
*cellFrame, cellSpacingX, availColWidth, availCellWidth);
|
|
|
|
// remember the rightmost (ltr) or leftmost (rtl) column this cell spans into
|
|
prevColIndex = (iter.IsLeftToRight()) ? cellColIndex + (cellColSpan - 1) : cellColIndex;
|
|
// always request MEW. Since we may turn MEW on for selected cells during incremental
|
|
// reflow, we need to request MEW *now* so that those incremental reflows will be
|
|
// able to build on existing MEW data in the children.
|
|
nsHTMLReflowMetrics desiredSize(PR_TRUE);
|
|
|
|
// If the avail width is not the same as last time we reflowed the cell or
|
|
// the cell wants to be bigger than what was available last time or
|
|
// it is a style change reflow or we are printing, then we must reflow the
|
|
// cell. Otherwise we can skip the reflow.
|
|
nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
|
|
nsSize cellDesiredSize = cellFrame->GetDesiredSize();
|
|
if ((availCellWidth != cellFrame->GetPriorAvailWidth()) ||
|
|
(cellDesiredSize.width > cellFrame->GetPriorAvailWidth()) ||
|
|
(eReflowReason_StyleChange == aReflowState.reason) ||
|
|
isPaginated ||
|
|
(cellFrame->NeedPass2Reflow() &&
|
|
NS_UNCONSTRAINEDSIZE != aReflowState.availableWidth) ||
|
|
(aReflowState.mFlags.mSpecialHeightReflow && cellFrame->NeedSpecialReflow()) ||
|
|
(!aReflowState.mFlags.mSpecialHeightReflow && cellFrame->HadSpecialReflow()) ||
|
|
HasPctHeight() ||
|
|
notifyStyleChange) {
|
|
// Reflow the cell to fit the available width, height
|
|
nsSize kidAvailSize(availColWidth, aReflowState.availableHeight);
|
|
nsReflowReason reason = eReflowReason_Resize;
|
|
PRBool cellToWatch = PR_FALSE;
|
|
// If it's a dirty frame, then check whether it's the initial reflow
|
|
if (kidFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW) {
|
|
reason = eReflowReason_Initial;
|
|
cellToWatch = PR_TRUE;
|
|
}
|
|
else if (eReflowReason_StyleChange == aReflowState.reason) {
|
|
reason = eReflowReason_StyleChange;
|
|
cellToWatch = PR_TRUE;
|
|
}
|
|
else if (notifyStyleChange) {
|
|
reason = eReflowReason_StyleChange;
|
|
cellToWatch = PR_TRUE;
|
|
}
|
|
if (cellToWatch) {
|
|
cellFrame->DidSetStyleContext(aPresContext); // XXX check this
|
|
if (!tablePrevInFlow && isAutoLayout) {
|
|
// request the maximum width if availWidth is constrained
|
|
// XXX we could just do this always, but blocks have some problems
|
|
if (NS_UNCONSTRAINEDSIZE != availCellWidth) {
|
|
desiredSize.mFlags |= NS_REFLOW_CALC_MAX_WIDTH;
|
|
}
|
|
}
|
|
else {
|
|
cellToWatch = PR_FALSE;
|
|
}
|
|
}
|
|
|
|
nscoord oldMaxWidth = cellFrame->GetMaximumWidth();
|
|
nscoord oldMaxElemWidth = cellFrame->GetPass1MaxElementWidth();
|
|
|
|
// Reflow the child
|
|
nsTableCellReflowState kidReflowState(aPresContext, aReflowState,
|
|
kidFrame, kidAvailSize, reason);
|
|
InitChildReflowState(*aPresContext, kidAvailSize, borderCollapse, p2t, kidReflowState);
|
|
|
|
nsReflowStatus status;
|
|
rv = ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowState,
|
|
x, 0, 0, status);
|
|
|
|
if (cellToWatch) {
|
|
nscoord maxWidth = (NS_UNCONSTRAINEDSIZE == availCellWidth)
|
|
? desiredSize.width : desiredSize.mMaximumWidth;
|
|
// save the max element width and max width
|
|
if (desiredSize.mComputeMEW) {
|
|
cellFrame->SetPass1MaxElementWidth(desiredSize.width, desiredSize.mMaxElementWidth);
|
|
if (desiredSize.mMaxElementWidth > desiredSize.width) {
|
|
desiredSize.width = desiredSize.mMaxElementWidth;
|
|
}
|
|
}
|
|
cellFrame->SetMaximumWidth(maxWidth);
|
|
}
|
|
|
|
// allow the table to determine if/how the table needs to be rebalanced
|
|
if (cellToWatch && needToNotifyTable) {
|
|
needToNotifyTable = !aTableFrame.CellChangedWidth(*cellFrame, oldMaxWidth, oldMaxElemWidth);
|
|
}
|
|
|
|
// If any of the cells are not complete, then we're not complete
|
|
if (NS_FRAME_IS_NOT_COMPLETE(status)) {
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
}
|
|
}
|
|
else {
|
|
desiredSize.width = cellDesiredSize.width;
|
|
desiredSize.height = cellDesiredSize.height;
|
|
nsRect *overflowArea =
|
|
cellFrame->GetOverflowAreaProperty();
|
|
if (overflowArea)
|
|
desiredSize.mOverflowArea = *overflowArea;
|
|
else
|
|
desiredSize.mOverflowArea.SetRect(0, 0, cellDesiredSize.width,
|
|
cellDesiredSize.height);
|
|
|
|
// if we are in a floated table, our position is not yet established, so we cannot reposition our views
|
|
// the containing glock will do this for us after positioning the table
|
|
if (!aTableFrame.GetStyleDisplay()->IsFloating()) {
|
|
// Because we may have moved the frame we need to make sure any views are
|
|
// positioned properly. We have to do this, because any one of our parent
|
|
// frames could have moved and we have no way of knowing...
|
|
nsTableFrame::RePositionViews(kidFrame);
|
|
}
|
|
}
|
|
|
|
if (NS_UNCONSTRAINEDSIZE == aReflowState.availableHeight) {
|
|
if (!mPrevInFlow) {
|
|
// Calculate the cell's actual size given its pass2 size. This function
|
|
// takes into account the specified height (in the style), and any special
|
|
// logic needed for backwards compatibility
|
|
CalculateCellActualSize(kidFrame, desiredSize.width,
|
|
desiredSize.height, availCellWidth);
|
|
}
|
|
// height may have changed, adjust descent to absorb any excess difference
|
|
nscoord ascent = cellFrame->GetDesiredAscent();
|
|
nscoord descent = desiredSize.height - ascent;
|
|
UpdateHeight(desiredSize.height, ascent, descent, &aTableFrame, cellFrame);
|
|
}
|
|
else {
|
|
paginatedHeight = PR_MAX(paginatedHeight, desiredSize.height);
|
|
PRInt32 rowSpan = aTableFrame.GetEffectiveRowSpan((nsTableCellFrame&)*kidFrame);
|
|
if (1 == rowSpan) {
|
|
SetContentHeight(paginatedHeight);
|
|
}
|
|
}
|
|
|
|
// Place the child
|
|
if (NS_UNCONSTRAINEDSIZE != availColWidth) {
|
|
desiredSize.width = PR_MAX(availCellWidth, availColWidth);
|
|
}
|
|
|
|
FinishReflowChild(kidFrame, aPresContext, nsnull, desiredSize, x, 0, 0);
|
|
|
|
x += desiredSize.width;
|
|
}
|
|
else {// it's an unknown frame type, give it a generic reflow and ignore the results
|
|
nsTableCellReflowState kidReflowState(aPresContext, aReflowState,
|
|
kidFrame, nsSize(0,0), eReflowReason_Resize);
|
|
InitChildReflowState(*aPresContext, nsSize(0,0), PR_FALSE, p2t, kidReflowState);
|
|
nsHTMLReflowMetrics desiredSize(PR_FALSE);
|
|
nsReflowStatus status;
|
|
ReflowChild(kidFrame, aPresContext, desiredSize, kidReflowState, 0, 0, 0, status);
|
|
kidFrame->DidReflow(aPresContext, nsnull, NS_FRAME_REFLOW_FINISHED);
|
|
}
|
|
}
|
|
else if (IS_TABLE_CELL(frameType)) {
|
|
// we need to account for the cell's width even if it isn't reflowed
|
|
x += kidFrame->GetSize().width;
|
|
}
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowArea, kidFrame);
|
|
kidFrame = iter.Next(); // Get the next child
|
|
x += cellSpacingX;
|
|
}
|
|
|
|
// just set our width to what was available. The table will calculate the width and not use our value.
|
|
aDesiredSize.width = aReflowState.availableWidth;
|
|
|
|
if (aReflowState.mFlags.mSpecialHeightReflow) {
|
|
aDesiredSize.height = mRect.height;
|
|
}
|
|
else if (NS_UNCONSTRAINEDSIZE == aReflowState.availableHeight) {
|
|
aDesiredSize.height = CalcHeight(aReflowState);
|
|
if (mPrevInFlow) {
|
|
nscoord height = CalcHeightFromUnpaginatedHeight(aPresContext, *this);
|
|
aDesiredSize.height = PR_MAX(aDesiredSize.height, height);
|
|
}
|
|
else {
|
|
if (isPaginated && HasStyleHeight()) {
|
|
// set the unpaginated height so next in flows can try to honor it
|
|
SetHasUnpaginatedHeight(PR_TRUE);
|
|
SetUnpaginatedHeight(aPresContext, aDesiredSize.height);
|
|
}
|
|
if (isPaginated && HasUnpaginatedHeight()) {
|
|
aDesiredSize.height = PR_MAX(aDesiredSize.height, GetUnpaginatedHeight(aPresContext));
|
|
}
|
|
}
|
|
}
|
|
else { // constrained height, paginated
|
|
aDesiredSize.height = paginatedHeight;
|
|
if (aDesiredSize.height <= aReflowState.availableHeight) {
|
|
nscoord height = CalcHeightFromUnpaginatedHeight(aPresContext, *this);
|
|
aDesiredSize.height = PR_MAX(aDesiredSize.height, height);
|
|
aDesiredSize.height = PR_MIN(aDesiredSize.height, aReflowState.availableHeight);
|
|
}
|
|
}
|
|
nsRect rowRect(0, 0, aDesiredSize.width, aDesiredSize.height);
|
|
aDesiredSize.mOverflowArea.UnionRect(aDesiredSize.mOverflowArea, rowRect);
|
|
FinishAndStoreOverflow(&aDesiredSize);
|
|
return rv;
|
|
}
|
|
|
|
NS_METHOD nsTableRowFrame::IncrementalReflow(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
CalcHeight(aReflowState); // need to recalculate it based on last reflow sizes
|
|
|
|
// the row is a target if its path has a reflow command
|
|
nsHTMLReflowCommand* command = aReflowState.path->mReflowCommand;
|
|
if (command)
|
|
IR_TargetIsMe(aPresContext, aDesiredSize, aReflowState, aTableFrame, aStatus);
|
|
|
|
// see if the chidren are targets as well
|
|
nsReflowPath::iterator iter = aReflowState.path->FirstChild();
|
|
nsReflowPath::iterator end = aReflowState.path->EndChildren();
|
|
for (; iter != end; ++iter)
|
|
IR_TargetIsChild(aPresContext, aDesiredSize, aReflowState, aTableFrame, aStatus, *iter);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_METHOD
|
|
nsTableRowFrame::IR_TargetIsMe(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
nsresult rv = NS_FRAME_COMPLETE;
|
|
|
|
nsReflowType type;
|
|
aReflowState.path->mReflowCommand->GetType(type);
|
|
switch (type) {
|
|
case eReflowType_ReflowDirty:
|
|
// Reflow the dirty child frames. Typically this is newly added frames.
|
|
rv = ReflowChildren(aPresContext, aDesiredSize, aReflowState, aTableFrame, aStatus, PR_TRUE);
|
|
break;
|
|
case eReflowType_StyleChanged :
|
|
rv = IR_StyleChanged(aPresContext, aDesiredSize, aReflowState, aTableFrame, aStatus);
|
|
break;
|
|
case eReflowType_ContentChanged :
|
|
NS_ASSERTION(PR_FALSE, "illegal reflow type: ContentChanged");
|
|
rv = NS_ERROR_ILLEGAL_VALUE;
|
|
break;
|
|
default:
|
|
NS_NOTYETIMPLEMENTED("unexpected reflow command type");
|
|
rv = NS_ERROR_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_METHOD
|
|
nsTableRowFrame::IR_StyleChanged(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
// we presume that all the easy optimizations were done in the nsHTMLStyleSheet before we were called here
|
|
// XXX: we can optimize this when we know which style attribute changed
|
|
aTableFrame.SetNeedStrategyInit(PR_TRUE);
|
|
rv = ReflowChildren(aPresContext, aDesiredSize, aReflowState, aTableFrame, aStatus, PR_FALSE);
|
|
return rv;
|
|
}
|
|
|
|
NS_METHOD
|
|
nsTableRowFrame::IR_TargetIsChild(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableFrame& aTableFrame,
|
|
nsReflowStatus& aStatus,
|
|
nsIFrame* aNextFrame)
|
|
|
|
{
|
|
if (!aNextFrame) return NS_ERROR_NULL_POINTER;
|
|
nsresult rv = NS_OK;
|
|
|
|
GET_PIXELS_TO_TWIPS(aPresContext, p2t);
|
|
PRBool isAutoLayout = aTableFrame.IsAutoLayout();
|
|
const nsStyleDisplay* childDisplay = aNextFrame->GetStyleDisplay();
|
|
if (NS_STYLE_DISPLAY_TABLE_CELL == childDisplay->mDisplay) {
|
|
nsTableCellFrame* cellFrame = (nsTableCellFrame*)aNextFrame;
|
|
// Get the x coord of the cell
|
|
nsPoint cellOrigin = cellFrame->GetPosition();
|
|
|
|
// At this point, we know the column widths. Compute the cell available width
|
|
PRInt32 cellColIndex;
|
|
cellFrame->GetColIndex(cellColIndex);
|
|
nscoord cellSpacingX = aTableFrame.GetCellSpacingX();
|
|
|
|
nscoord colAvailWidth, cellAvailWidth;
|
|
CalcAvailWidth(aTableFrame, GetComputedWidth(aReflowState, aTableFrame), p2t,
|
|
*cellFrame, cellSpacingX, colAvailWidth, cellAvailWidth);
|
|
|
|
// Always let the cell be as high as it wants. We ignore the height that's
|
|
// passed in and always place the entire row. Let the row group decide
|
|
// whether we fit or wehther the entire row is pushed
|
|
nsSize cellAvailSize(cellAvailWidth, NS_UNCONSTRAINEDSIZE);
|
|
|
|
// Pass along the reflow command
|
|
// Unless this is a fixed-layout table, then have the cell incrementally
|
|
// update its maximum width.
|
|
nsHTMLReflowMetrics cellMet(PR_TRUE,
|
|
isAutoLayout ? NS_REFLOW_CALC_MAX_WIDTH : 0);
|
|
GET_PIXELS_TO_TWIPS(aPresContext, p2t);
|
|
nsTableCellReflowState kidRS(aPresContext, aReflowState, aNextFrame, cellAvailSize,
|
|
aReflowState.reason);
|
|
// If the table will intialize the strategy (and balance) or balance, make the computed
|
|
// width unconstrained. This avoids having the cell block compute a bogus max width
|
|
// which will bias the balancing. Leave the avail width alone, since it is a best guess.
|
|
// After the table balances, the cell will get reflowed with the correct computed width.
|
|
PRBool resetComputedWidth = aTableFrame.NeedStrategyInit() || aTableFrame.NeedStrategyBalance();
|
|
if (resetComputedWidth)
|
|
cellFrame->SetNeedPass2Reflow(PR_TRUE);
|
|
InitChildReflowState(*aPresContext, cellAvailSize, aTableFrame.IsBorderCollapse(),
|
|
p2t, kidRS, resetComputedWidth);
|
|
|
|
// Remember the current desired size, we'll need it later
|
|
nscoord oldCellMinWidth = cellFrame->GetPass1MaxElementWidth();
|
|
nscoord oldCellMaximumWidth = cellFrame->GetMaximumWidth();
|
|
nsSize oldCellDesSize = cellFrame->GetDesiredSize();
|
|
nscoord oldCellDesAscent = cellFrame->GetDesiredAscent();
|
|
nscoord oldCellDesDescent = oldCellDesSize.height - oldCellDesAscent;
|
|
|
|
// Reflow the cell passing it the incremental reflow command. We can't pass
|
|
// in a max width of NS_UNCONSTRAINEDSIZE, because the max width must match
|
|
// the width of the previous reflow...
|
|
rv = ReflowChild(aNextFrame, aPresContext, cellMet, kidRS,
|
|
cellOrigin.x, 0, 0, aStatus);
|
|
nsSize initCellDesSize(cellMet.width, cellMet.height);
|
|
nscoord initCellDesAscent = cellMet.ascent;
|
|
nscoord initCellDesDescent = cellMet.descent;
|
|
|
|
// cache the max-elem and maximum widths
|
|
cellFrame->SetPass1MaxElementWidth(cellMet.width, cellMet.mMaxElementWidth);
|
|
cellFrame->SetMaximumWidth(cellMet.mMaximumWidth);
|
|
|
|
// Calculate the cell's actual size given its pass2 size. This function
|
|
// takes into account the specified height (in the style), and any special
|
|
// logic needed for backwards compatibility
|
|
CalculateCellActualSize(aNextFrame, cellMet.width, cellMet.height, cellAvailWidth);
|
|
|
|
// height may have changed, adjust descent to absorb any excess difference
|
|
cellMet.descent = cellMet.height - cellMet.ascent;
|
|
|
|
// if the cell got shorter and it may have been the tallest, recalc the tallest cell
|
|
PRBool tallestCellGotShorter = PR_FALSE;
|
|
PRBool hasVerticalAlignBaseline = cellFrame->HasVerticalAlignBaseline();
|
|
if (!hasVerticalAlignBaseline) {
|
|
// only the height matters
|
|
tallestCellGotShorter =
|
|
TallestCellGotShorter(oldCellDesSize.height, cellMet.height, GetHeight());
|
|
}
|
|
else {
|
|
// the ascent matters
|
|
tallestCellGotShorter =
|
|
TallestCellGotShorter(oldCellDesAscent, cellMet.ascent, mMaxCellAscent);
|
|
// the descent of cells without rowspan also matters
|
|
if (!tallestCellGotShorter) {
|
|
PRInt32 rowSpan = aTableFrame.GetEffectiveRowSpan(*cellFrame);
|
|
if (rowSpan == 1) {
|
|
tallestCellGotShorter =
|
|
TallestCellGotShorter(oldCellDesDescent, cellMet.descent, mMaxCellDescent);
|
|
}
|
|
}
|
|
}
|
|
if (tallestCellGotShorter) {
|
|
CalcHeight(aReflowState);
|
|
}
|
|
else {
|
|
UpdateHeight(cellMet.height, cellMet.ascent, cellMet.descent, &aTableFrame, cellFrame);
|
|
}
|
|
|
|
// if the cell's desired size didn't changed, our height is unchanged
|
|
aDesiredSize.mNothingChanged = PR_FALSE;
|
|
PRInt32 rowSpan = aTableFrame.GetEffectiveRowSpan(*cellFrame);
|
|
if ((initCellDesSize.width == oldCellDesSize.width) &&
|
|
(initCellDesSize.height == oldCellDesSize.height) &&
|
|
(oldCellMaximumWidth == cellMet.mMaximumWidth)) {
|
|
if (!hasVerticalAlignBaseline) { // only the cell's height matters
|
|
aDesiredSize.mNothingChanged = PR_TRUE;
|
|
}
|
|
else { // cell's ascent and cell's descent matter
|
|
if (initCellDesAscent == oldCellDesAscent) {
|
|
if ((rowSpan == 1) && (initCellDesDescent == oldCellDesDescent)) {
|
|
aDesiredSize.mNothingChanged = PR_TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
aDesiredSize.height = (aDesiredSize.mNothingChanged) ? mRect.height : GetHeight();
|
|
if (1 == rowSpan) {
|
|
cellMet.height = aDesiredSize.height;
|
|
}
|
|
else {
|
|
nscoord heightOfRows = aDesiredSize.height + GetHeightOfRowsSpannedBelowFirst(*cellFrame, aTableFrame);
|
|
cellMet.height = PR_MAX(cellMet.height, heightOfRows);
|
|
// XXX need to check what happens when this height differs from height of the cell's previous mRect.height
|
|
}
|
|
|
|
// Now place the child
|
|
cellMet.width = colAvailWidth;
|
|
FinishReflowChild(aNextFrame, aPresContext, nsnull, cellMet, cellOrigin.x, 0, 0);
|
|
|
|
// Notify the table if the cell width changed so it can decide whether to rebalance
|
|
if (!aDesiredSize.mNothingChanged) {
|
|
aTableFrame.CellChangedWidth(*cellFrame, oldCellMinWidth, oldCellMaximumWidth);
|
|
}
|
|
|
|
// Return our desired size. Note that our desired width is just whatever width
|
|
// we were given by the row group frame
|
|
aDesiredSize.width = aReflowState.availableWidth;
|
|
if (!aDesiredSize.mNothingChanged) {
|
|
if (aDesiredSize.height == mRect.height) { // our height didn't change
|
|
cellFrame->VerticallyAlignChild(aReflowState, mMaxCellAscent);
|
|
nsRect dirtyRect = cellFrame->GetRect();
|
|
dirtyRect.height = mRect.height;
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowArea, cellFrame);
|
|
dirtyRect.UnionRect(dirtyRect, aDesiredSize.mOverflowArea);
|
|
Invalidate(dirtyRect);
|
|
}
|
|
}
|
|
else { // we dont realign vertical but we need to update the overflow area
|
|
nsIFrame* cellKidFrame = cellFrame->GetFirstChild(nsnull);
|
|
if (cellKidFrame) {
|
|
// XXX This is bogus. The code above changes the cell width
|
|
// and height but leaves the overflow area alone. How can that
|
|
// be right?
|
|
|
|
// Make sure the overflow area includes the width and height, in any case.
|
|
cellMet.mOverflowArea.UnionRect(cellMet.mOverflowArea,
|
|
nsRect(0, 0, cellMet.width, cellMet.height));
|
|
cellFrame->ConsiderChildOverflow(cellMet.mOverflowArea, cellKidFrame);
|
|
cellFrame->FinishAndStoreOverflow(&cellMet);
|
|
if (cellFrame->HasView()) {
|
|
nsContainerFrame::SyncFrameViewAfterReflow(aPresContext, cellFrame, cellFrame->GetView(), &cellMet.mOverflowArea, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{ // pass reflow to unknown frame child
|
|
// aDesiredSize does not change
|
|
}
|
|
|
|
// recover the overflow area
|
|
aDesiredSize.mOverflowArea = nsRect(0, 0, aDesiredSize.width, aDesiredSize.height);
|
|
for (nsIFrame* cell = mFrames.FirstChild(); cell; cell = cell->GetNextSibling()) {
|
|
ConsiderChildOverflow(aDesiredSize.mOverflowArea, cell);
|
|
}
|
|
FinishAndStoreOverflow(&aDesiredSize);
|
|
// When returning whether we're complete we need to look at each of our cell
|
|
// frames. If any of them has a continuing frame, then we're not complete. We
|
|
// can't just return the status of the cell frame we just reflowed...
|
|
aStatus = NS_FRAME_COMPLETE;
|
|
if (mNextInFlow) {
|
|
for (nsIFrame* cell = mFrames.FirstChild(); cell;
|
|
cell = cell->GetNextSibling()) {
|
|
nsIFrame* contFrame = cell->GetNextInFlow();
|
|
if (contFrame) {
|
|
aStatus = NS_FRAME_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
|
|
/** Layout the entire row.
|
|
* This method stacks cells horizontally according to HTML 4.0 rules.
|
|
*/
|
|
NS_METHOD
|
|
nsTableRowFrame::Reflow(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
DO_GLOBAL_REFLOW_COUNT("nsTableRowFrame", aReflowState.reason);
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
|
|
#if defined DEBUG_TABLE_REFLOW_TIMING
|
|
nsTableFrame::DebugReflow(this, (nsHTMLReflowState&)aReflowState);
|
|
#endif
|
|
nsresult rv = NS_OK;
|
|
|
|
nsTableFrame* tableFrame = nsnull;
|
|
rv = nsTableFrame::GetTableFrame(this, tableFrame);
|
|
if (!tableFrame) return NS_ERROR_NULL_POINTER;
|
|
|
|
const nsStyleVisibility* rowVis = GetStyleVisibility();
|
|
PRBool collapseRow = (NS_STYLE_VISIBILITY_COLLAPSE == rowVis->mVisible);
|
|
if (collapseRow) {
|
|
tableFrame->SetNeedToCollapseRows(PR_TRUE);
|
|
}
|
|
|
|
// see if a special height reflow needs to occur due to having a pct height
|
|
if (!NeedSpecialReflow())
|
|
nsTableFrame::CheckRequestSpecialHeightReflow(aReflowState);
|
|
|
|
switch (aReflowState.reason) {
|
|
case eReflowReason_Initial:
|
|
rv = ReflowChildren(aPresContext, aDesiredSize, aReflowState, *tableFrame, aStatus, PR_FALSE);
|
|
break;
|
|
|
|
case eReflowReason_Resize:
|
|
case eReflowReason_StyleChange:
|
|
case eReflowReason_Dirty:
|
|
rv = ReflowChildren(aPresContext, aDesiredSize, aReflowState, *tableFrame, aStatus, PR_FALSE);
|
|
break;
|
|
|
|
case eReflowReason_Incremental:
|
|
rv = IncrementalReflow(aPresContext, aDesiredSize, aReflowState, *tableFrame, aStatus);
|
|
break;
|
|
default:
|
|
NS_ASSERTION(PR_FALSE , "we should handle this reflow reason");
|
|
rv = NS_ERROR_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
|
|
// just set our width to what was available. The table will calculate the width and not use our value.
|
|
aDesiredSize.width = aReflowState.availableWidth;
|
|
|
|
if (aReflowState.mFlags.mSpecialHeightReflow) {
|
|
SetNeedSpecialReflow(PR_FALSE);
|
|
}
|
|
|
|
#if defined DEBUG_TABLE_REFLOW_TIMING
|
|
nsTableFrame::DebugReflow(this, (nsHTMLReflowState&)aReflowState, &aDesiredSize, aStatus);
|
|
#endif
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
|
|
return rv;
|
|
}
|
|
|
|
/**
|
|
* This function is called by the row group frame's SplitRowGroup() code when
|
|
* pushing a row frame that has cell frames that span into it. The cell frame
|
|
* should be reflowed with the specified height
|
|
*/
|
|
nscoord
|
|
nsTableRowFrame::ReflowCellFrame(nsPresContext* aPresContext,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsTableCellFrame* aCellFrame,
|
|
nscoord aAvailableHeight,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
nsTableFrame* tableFrame = nsnull;
|
|
nsTableFrame::GetTableFrame(this, tableFrame); if (!tableFrame) ABORT1(0);
|
|
|
|
// Reflow the cell frame with the specified height. Use the existing width
|
|
nsSize cellSize = aCellFrame->GetSize();
|
|
|
|
nsSize availSize(cellSize.width, aAvailableHeight);
|
|
PRBool borderCollapse = ((nsTableFrame*)tableFrame->GetFirstInFlow())->IsBorderCollapse();
|
|
GET_PIXELS_TO_TWIPS(aPresContext, p2t);
|
|
nsTableCellReflowState cellReflowState(aPresContext, aReflowState, aCellFrame, availSize,
|
|
eReflowReason_Resize);
|
|
InitChildReflowState(*aPresContext, availSize, borderCollapse, p2t, cellReflowState);
|
|
|
|
nsHTMLReflowMetrics desiredSize(PR_FALSE);
|
|
|
|
ReflowChild(aCellFrame, aPresContext, desiredSize, cellReflowState,
|
|
0, 0, NS_FRAME_NO_MOVE_FRAME, aStatus);
|
|
PRBool fullyComplete = NS_FRAME_IS_COMPLETE(aStatus) && !NS_FRAME_IS_TRUNCATED(aStatus);
|
|
|
|
aCellFrame->SetSize(
|
|
nsSize(cellSize.width, fullyComplete ? aAvailableHeight : desiredSize.height));
|
|
|
|
// XXX What happens if this cell has 'vertical-align: baseline' ?
|
|
// XXX Why is it assumed that the cell's ascent hasn't changed ?
|
|
if (fullyComplete) {
|
|
aCellFrame->VerticallyAlignChild(aReflowState, mMaxCellAscent);
|
|
}
|
|
aCellFrame->DidReflow(aPresContext, nsnull, NS_FRAME_REFLOW_FINISHED);
|
|
|
|
return desiredSize.height;
|
|
}
|
|
|
|
/**
|
|
* These 3 functions are called by the row group frame's SplitRowGroup() code when
|
|
* it creates a continuing cell frame and wants to insert it into the row's child list
|
|
*/
|
|
void
|
|
nsTableRowFrame::InsertCellFrame(nsTableCellFrame* aFrame,
|
|
nsTableCellFrame* aPrevSibling)
|
|
{
|
|
mFrames.InsertFrame(nsnull, aPrevSibling, aFrame);
|
|
aFrame->SetParent(this);
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::InsertCellFrame(nsTableCellFrame* aFrame,
|
|
PRInt32 aColIndex)
|
|
{
|
|
// Find the cell frame where col index < aColIndex
|
|
nsTableCellFrame* priorCell = nsnull;
|
|
for (nsIFrame* child = mFrames.FirstChild(); child;
|
|
child = child->GetNextSibling()) {
|
|
if (!IS_TABLE_CELL(child->GetType())) {
|
|
nsTableCellFrame* cellFrame = (nsTableCellFrame*)child;
|
|
PRInt32 colIndex;
|
|
cellFrame->GetColIndex(colIndex);
|
|
if (colIndex < aColIndex) {
|
|
priorCell = cellFrame;
|
|
}
|
|
else break;
|
|
}
|
|
}
|
|
InsertCellFrame(aFrame, priorCell);
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::RemoveCellFrame(nsTableCellFrame* aFrame)
|
|
{
|
|
if (!mFrames.RemoveFrame(aFrame))
|
|
NS_ASSERTION(PR_FALSE, "frame not in list");
|
|
}
|
|
|
|
nsIAtom*
|
|
nsTableRowFrame::GetType() const
|
|
{
|
|
return nsLayoutAtoms::tableRowFrame;
|
|
}
|
|
|
|
nsTableRowFrame*
|
|
nsTableRowFrame::GetNextRow() const
|
|
{
|
|
nsIFrame* childFrame = GetNextSibling();
|
|
while (childFrame) {
|
|
if (nsLayoutAtoms::tableRowFrame == childFrame->GetType()) {
|
|
return (nsTableRowFrame*)childFrame;
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
return nsnull;
|
|
}
|
|
|
|
void
|
|
nsTableRowFrame::SetUnpaginatedHeight(nsPresContext* aPresContext,
|
|
nscoord aValue)
|
|
{
|
|
NS_ASSERTION(!mPrevInFlow, "program error");
|
|
// Get the property
|
|
nscoord* value = (nscoord*)nsTableFrame::GetProperty(this, nsLayoutAtoms::rowUnpaginatedHeightProperty, PR_TRUE);
|
|
if (value) {
|
|
*value = aValue;
|
|
}
|
|
}
|
|
|
|
nscoord
|
|
nsTableRowFrame::GetUnpaginatedHeight(nsPresContext* aPresContext)
|
|
{
|
|
// See if the property is set
|
|
nscoord* value = (nscoord*)nsTableFrame::GetProperty(GetFirstInFlow(), nsLayoutAtoms::rowUnpaginatedHeightProperty);
|
|
if (value)
|
|
return *value;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
void nsTableRowFrame::SetContinuousBCBorderWidth(PRUint8 aForSide,
|
|
BCPixelSize aPixelValue)
|
|
{
|
|
switch (aForSide) {
|
|
case NS_SIDE_RIGHT:
|
|
mRightContBorderWidth = aPixelValue;
|
|
return;
|
|
case NS_SIDE_TOP:
|
|
mTopContBorderWidth = aPixelValue;
|
|
return;
|
|
case NS_SIDE_LEFT:
|
|
mLeftContBorderWidth = aPixelValue;
|
|
return;
|
|
default:
|
|
NS_ERROR("invalid NS_SIDE arg");
|
|
}
|
|
}
|
|
|
|
/* ----- global methods ----- */
|
|
|
|
nsresult
|
|
NS_NewTableRowFrame(nsIPresShell* aPresShell, nsIFrame** aNewFrame)
|
|
{
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
if (nsnull == aNewFrame) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
nsTableRowFrame* it = new (aPresShell) nsTableRowFrame;
|
|
if (nsnull == it) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
*aNewFrame = it;
|
|
return NS_OK;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
NS_IMETHODIMP
|
|
nsTableRowFrame::GetFrameName(nsAString& aResult) const
|
|
{
|
|
return MakeFrameName(NS_LITERAL_STRING("TableRow"), aResult);
|
|
}
|
|
#endif
|