gecko-dev/layout/tables/nsTableOuterFrame.cpp

/* -*- 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"
#include "nsTableCaptionFrame.h"
#include "nsITableContent.h"
#include "nsTableContent.h"
#include "nsBodyFrame.h"
#include "nsReflowCommand.h"
#include "nsIStyleContext.h"
#include "nsStyleConsts.h"
#include "nsIPresContext.h"
#include "nsIRenderingContext.h"
#include "nsCSSRendering.h"
#include "nsIContent.h"
#include "nsIContentDelegate.h"
#include "nsCSSLayout.h"
#include "nsVoidArray.h"
#include "nsReflowCommand.h"
#include "nsIPtr.h"

#ifdef NS_DEBUG
static PRBool gsDebug = PR_FALSE;
//#define NOISY
//#define NOISY_FLOW
#define NOISY_MARGINS
#else
static const PRBool gsDebug = PR_FALSE;
#endif

static NS_DEFINE_IID(kITableContentIID, NS_ITABLECONTENT_IID);

NS_DEF_PTR(nsIStyleContext);
NS_DEF_PTR(nsIContent);

struct OuterTableReflowState {

  // The presentation context
  nsIPresContext *pc;

  // Our reflow state
  const nsReflowState& reflowState;

  // 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;

  // Flags for where we are in the content
  PRBool firstRowGroup;
  PRBool processingCaption;

  OuterTableReflowState(nsIPresContext*      aPresContext,
                        const nsReflowState& aReflowState)
    : reflowState(aReflowState)
  {
    pc = aPresContext;
    availSize.width = reflowState.maxSize.width;
    availSize.height = reflowState.maxSize.height;
    prevMaxPosBottomMargin = 0;
    prevMaxNegBottomMargin = 0;
    y=0;  // border/padding/margin???
    unconstrainedWidth = PRBool(aReflowState.maxSize.width == NS_UNCONSTRAINEDSIZE);
    unconstrainedHeight = PRBool(aReflowState.maxSize.height == NS_UNCONSTRAINEDSIZE);
    firstRowGroup = PR_TRUE;
    processingCaption = PR_FALSE;
    innerTableMaxSize.width=0;
    innerTableMaxSize.height=0;
  }

  ~OuterTableReflowState() {
  }
};



/* ----------- nsTableOuterFrame ---------- */


/**
  */
nsTableOuterFrame::nsTableOuterFrame(nsIContent* aContent, nsIFrame* aParentFrame)
  : nsContainerFrame(aContent, aParentFrame),
  mInnerTableFrame(nsnull),
  mCaptionFrames(nsnull),
  mBottomCaptions(nsnull),
  mMinCaptionWidth(0),
  mMaxCaptionWidth(0),
  mFirstPassValid(PR_FALSE),
  mDesiredSize(nsnull)
{
}

nsTableOuterFrame::~nsTableOuterFrame()
{
  if (nsnull!=mCaptionFrames)
    delete mCaptionFrames;
  if (nsnull!=mBottomCaptions)
    delete mBottomCaptions;
}

NS_METHOD nsTableOuterFrame::Paint(nsIPresContext& aPresContext,
                                   nsIRenderingContext& aRenderingContext,
                                   const nsRect& aDirtyRect)
{
  // for debug...
  if (nsIFrame::GetShowFrameBorders()) {
    aRenderingContext.SetColor(NS_RGB(255,0,0));
    aRenderingContext.DrawRect(0, 0, mRect.width, mRect.height);
  }

  PaintChildren(aPresContext, aRenderingContext, aDirtyRect);
  return NS_OK;
}

PRBool nsTableOuterFrame::NeedsReflow(const nsSize& aMaxSize)
{
  PRBool result=PR_TRUE;
  if (nsnull!=mInnerTableFrame)
    result = mInnerTableFrame->NeedsReflow(aMaxSize);
  return result;
}

PRBool nsTableOuterFrame::IsFirstPassValid()
{
  return mFirstPassValid;
}

void nsTableOuterFrame::SetFirstPassValid(PRBool aValidState)
{
  mFirstPassValid = aValidState;
}

/**
  * Reflow is a 2-step process.
  * In the first step, we lay out all of the captions and the inner table in NS_UNCONSTRAINEDSIZE space.
  * This gives us absolute minimum and maximum widths.
  * In the second step, we force all the captions and the table to the width of the widest component, 
  * given the table's width constraints.
  * With the widths known, we reflow the captions and table.
  * NOTE: for breaking across pages, this method has to account for table content that is not laid out
  *       linearly vis a vis the frames.  That is, content hierarchy and the frame hierarchy do not match.
  */
NS_METHOD nsTableOuterFrame::Reflow(nsIPresContext* aPresContext,
                                    nsReflowMetrics& aDesiredSize,
                                    const nsReflowState& aReflowState,
                                    nsReflowStatus& aStatus)
{
  if (PR_TRUE==gsDebug) 
    printf ("***table outer frame reflow \t\t%p\n", this);
  if (PR_TRUE==gsDebug)
    printf("nsTableOuterFrame::Reflow : maxSize=%d,%d\n",
           aReflowState.maxSize.width, aReflowState.maxSize.height);

#ifdef NS_DEBUG
  // replace with a check that does not assume linear placement of children
  // PreReflowCheck();
#endif

  // Initialize out parameter
  if (nsnull != aDesiredSize.maxElementSize) {
    aDesiredSize.maxElementSize->width = 0;
    aDesiredSize.maxElementSize->height = 0;
  }

  PRBool  reflowMappedOK = PR_TRUE;

  aStatus = NS_FRAME_COMPLETE;

  // Set up our kids.  They're already present, on an overflow list, 
  // or there are none so we'll create them now
  MoveOverflowToChildList();
  if (nsnull==mFirstChild)
    CreateChildFrames(aPresContext);
  if (nsnull!=mPrevInFlow && nsnull==mInnerTableFrame)
  { // if I am a continuing frame, my inner table is my prev-in-flow's mInnerTableFrame's next-in-flow
    CreateInnerTableFrame(aPresContext);
  }
  // at this point, we must have at least one child frame, and we must have an inner table frame
  NS_ASSERTION(nsnull!=mFirstChild, "no children");
  NS_ASSERTION(nsnull!=mInnerTableFrame, "no mInnerTableFrame");
  if (nsnull==mFirstChild  ||  nsnull==mInnerTableFrame) {
    //ERROR!
    aStatus = NS_FRAME_COMPLETE;
    return NS_OK;
  }
  
  OuterTableReflowState state(aPresContext, aReflowState);

  // lay out captions pass 1, if necessary
  if (PR_FALSE==IsFirstPassValid())
  {
    mFirstPassValid = PR_TRUE;
    aStatus = ResizeReflowCaptionsPass1(aPresContext, state);

  }

  // lay out inner table, if required
  if (PR_FALSE==mInnerTableFrame->IsFirstPassValid())
  { 
   // we treat the table as if we've never seen the layout data before
 
    mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_FIRST);
    nsReflowState innerTableReflowState(mInnerTableFrame, aReflowState, aReflowState.maxSize);
    aStatus = mInnerTableFrame->ResizeReflowPass1(aPresContext, aDesiredSize,
                                                  innerTableReflowState);
  }
  mInnerTableFrame->SetReflowPass(nsTableFrame::kPASS_SECOND);
  // assign table width info only if the inner table frame is a first-in-flow
  nsIFrame* prevInFlow;

  mInnerTableFrame->GetPrevInFlow(prevInFlow);
  if (nsnull==prevInFlow)
  {
    // assign column widths, and assign aMaxElementSize->width
    mInnerTableFrame->BalanceColumnWidths(aPresContext, aReflowState,
                                          aReflowState.maxSize,
                                          aDesiredSize.maxElementSize);
    // assign table width
    mInnerTableFrame->SetTableWidth(aPresContext);
  }
  // inner table max is now the computed width and assigned  height
  nsSize  innerTableSize(0,0);

  mInnerTableFrame->GetSize(innerTableSize);
  state.innerTableMaxSize.width = innerTableSize.width;
  state.innerTableMaxSize.height = aReflowState.maxSize.height; 

  // Reflow the child frames
  if (nsnull != mFirstChild) {
    reflowMappedOK = ReflowMappedChildren(aPresContext, state, aDesiredSize.maxElementSize);
    if (PR_FALSE == reflowMappedOK) {
      aStatus = NS_FRAME_NOT_COMPLETE;
    }
  }

  // Did we successfully relow our mapped children?
  if (PR_TRUE == reflowMappedOK) {
    // Any space left?
    if (state.availSize.height <= 0) {
      // No space left. Don't try to pull-up children or reflow unmapped
      if (NextChildOffset() < mContent->ChildCount()) {
        aStatus = NS_FRAME_NOT_COMPLETE;
      }
    } else if (NextChildOffset() < mContent->ChildCount()) {
      // Try and pull-up some children from a next-in-flow
      if (PullUpChildren(aPresContext, state, aDesiredSize.maxElementSize)) {
        // If we still have unmapped children then create some new frames
        NS_ABORT(); // huge error for tables!
      } else {
        // We were unable to pull-up all the existing frames from the next in flow
        aStatus = NS_FRAME_NOT_COMPLETE;
      }
    }
  }

  if (NS_FRAME_IS_COMPLETE(aStatus)) {
    // Don't forget to add in the bottom margin from our last child.
    // Only add it in if there's room for it.
    nscoord margin = state.prevMaxPosBottomMargin -
      state.prevMaxNegBottomMargin;
    if (state.availSize.height >= margin) {
      state.y += margin;
    }
  }

  // Return our desired rect
  //NS_ASSERTION(0<state.y, "illegal height after reflow");
  //NS_ASSERTION(0<state.innerTableMaxSize.width, "illegal width after reflow");
  aDesiredSize.width  = state.innerTableMaxSize.width;
  /* if we're incomplete, take up all the remaining height so we don't waste time
   * trying to lay out in a slot that we know isn't tall enough to fit our minimum.
   * otherwise, we're as tall as our kids want us to be */
  if (NS_FRAME_IS_NOT_COMPLETE(aStatus))
    aDesiredSize.height = aReflowState.maxSize.height;
  else 
    aDesiredSize.height = state.y;

  if (gsDebug==PR_TRUE) 
  {
    if (nsnull!=aDesiredSize.maxElementSize)
      printf("Outer frame Reflow complete, returning %s with aDesiredSize = %d,%d and aMaxElementSize=%d,%d\n",
              NS_FRAME_IS_COMPLETE(aStatus)? "Complete" : "Not Complete",
              aDesiredSize.width, aDesiredSize.height, 
              aDesiredSize.maxElementSize->width, aDesiredSize.maxElementSize->height);
    else
      printf("Outer frame Reflow complete, returning %s with aDesiredSize = %d,%d and NSNULL aMaxElementSize\n",
              NS_FRAME_IS_COMPLETE(aStatus)? "Complete" : "Not Complete",
              aDesiredSize.width, aDesiredSize.height);
  }

#ifdef NS_DEBUG
  // replace with a check that does not assume linear placement of children
  // PostReflowCheck(status);
#endif
  // REMOVE ME!
  /*
  nsIFrame *next = this;
  nsIFrame *root=nsnull;
  while (nsnull!=next)
  {
	  root = next;
	  next = next->GetGeometricParent();
  }
  root->List();
  */
  // end REMOVE ME!

  return NS_OK;

}

// Collapse child's top margin with previous bottom margin
nscoord nsTableOuterFrame::GetTopMarginFor(nsIPresContext*        aCX,
                                           OuterTableReflowState& aState,
                                           const nsMargin& aKidMargin)
{
  nscoord margin;
  nscoord maxNegTopMargin = 0;
  nscoord maxPosTopMargin = 0;
  if ((margin = aKidMargin.top) < 0) {
    maxNegTopMargin = -margin;
  } else {
    maxPosTopMargin = margin;
  }

  nscoord maxPos = PR_MAX(aState.prevMaxPosBottomMargin, maxPosTopMargin);
  nscoord maxNeg = PR_MAX(aState.prevMaxNegBottomMargin, maxNegTopMargin);
  margin = maxPos - maxNeg;

  return margin;
}

// 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.
void nsTableOuterFrame::PlaceChild( OuterTableReflowState& aState,
                                    nsIFrame*          aKidFrame,
                                    const nsRect&      aKidRect,
                                    nsSize*            aMaxElementSize,
                                    nsSize&            aKidMaxElementSize)
{
  if (PR_TRUE==gsDebug) 
    printf ("outer table place child: %p with aKidRect %d %d %d %d\n", 
                                 aKidFrame, aKidRect.x, aKidRect.y,
                                 aKidRect.width, aKidRect.height);
  // Place and size the child
  aKidFrame->SetRect(aKidRect);

  // Adjust the running y-offset
  aState.y += aKidRect.height;

  // If our height is constrained then update the available height
  if (PR_FALSE == aState.unconstrainedHeight) {
    aState.availSize.height -= aKidRect.height;
  }

  /* Update the maximum element size, which is the sum of:
   *   the maxElementSize of our first row
   *   plus the maxElementSize of the top caption if we include it
   *   plus the maxElementSize of the bottom caption if we include it
   */
  if (PR_TRUE==aState.processingCaption || PR_TRUE==aState.firstRowGroup)
  {
    if (PR_FALSE==aState.processingCaption)
      aState.firstRowGroup = PR_FALSE;
    if (nsnull != aMaxElementSize) {
      aMaxElementSize->width = aKidMaxElementSize.width;
      aMaxElementSize->height = aKidMaxElementSize.height;
    }
  }
}

/**
 * Reflow the frames we've already created
 *
 * @param   aPresContext presentation context to use
 * @param   aState current inline state
 * @return  true if we successfully reflowed all the mapped children and false
 *            otherwise, e.g. we pushed children to the next in flow
 */
PRBool nsTableOuterFrame::ReflowMappedChildren( nsIPresContext*      aPresContext,
                                                OuterTableReflowState& aState,
                                                nsSize*              aMaxElementSize)
{
#ifdef NS_DEBUG
  VerifyLastIsComplete();
#endif
#ifdef NOISY
  ListTag(stdout);
  printf(": reflow mapped (childCount=%d) [%d,%d,%c]\n",
         mChildCount,
         mFirstContentOffset, mLastContentOffset,
         (mLastContentIsComplete ? 'T' : 'F'));
#ifdef NOISY_FLOW
  {
    nsTableOuterFrame* flow = (nsTableOuterFrame*) mNextInFlow;
    while (flow != 0) {
      printf("  %p: [%d,%d,%c]\n",
             flow, flow->mFirstContentOffset, flow->mLastContentOffset,
             (flow->mLastContentIsComplete ? 'T' : 'F'));
      flow = (nsTableOuterFrame*) flow->mNextInFlow;
    }
  }
#endif
#endif
  NS_PRECONDITION(nsnull != mFirstChild, "no children");

  PRInt32   childCount = 0;
  nsIFrame* prevKidFrame = nsnull;

  // Remember our original mLastContentIsComplete so that if we end up
  // having to push children, we have the correct value to hand to
  // PushChildren.
  PRBool    originalLastContentIsComplete = mLastContentIsComplete;

  nsSize    kidMaxElementSize(0,0);
  nsSize*   pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
  PRBool    result = PR_TRUE;
  aState.availSize.width = aState.innerTableMaxSize.width;
  for (nsIFrame* kidFrame = mFirstChild; nsnull != kidFrame; ) {
    nsReflowMetrics   kidSize(pKidMaxElementSize);
    kidSize.width=kidSize.height=kidSize.ascent=kidSize.descent=0;
    nsReflowStatus    status;

    SetReflowState(aState, kidFrame);

    if (PR_TRUE==gsDebug) printf ("ReflowMappedChildren: %p with state = %s\n", 
                                  kidFrame, aState.processingCaption?"caption":"inner");

    // Get top margin for this kid
    nsIStyleContextPtr kidSC;

    kidFrame->GetStyleContext(aPresContext, kidSC.AssignRef());
    const nsStyleSpacing* kidSpacing =
      (const nsStyleSpacing*)kidSC->GetStyleData(eStyleStruct_Spacing);
    nsMargin kidMargin;
    kidSpacing->CalcMarginFor(kidFrame, kidMargin);
    nscoord topMargin = GetTopMarginFor(aPresContext, aState, kidMargin);
    nscoord bottomMargin = kidMargin.bottom;

    // Figure out the amount of available size for the child (subtract
    // off the top margin we are going to apply to it)
    if (PR_FALSE == aState.unconstrainedHeight) {
      aState.availSize.height -= topMargin;
    }
    // Subtract off for left and right margin
    if (PR_FALSE == aState.unconstrainedWidth) {
      aState.availSize.width -= kidMargin.left + kidMargin.right;
    }

    // Only skip the reflow if this is not our first child and we are
    // out of space.
    if ((kidFrame == mFirstChild) || (aState.availSize.height > 0)) {
      // Reflow the child into the available space
      kidFrame->WillReflow(*aPresContext);
      status = ReflowChild(kidFrame, aPresContext, kidSize,
                           aState.availSize, pKidMaxElementSize,
                           aState);
    }

    // Did the child fit?
    if ((kidSize.height > aState.availSize.height) && (kidFrame != mFirstChild)) {
      // The child is too tall to fit in the available space, and it's
      // not our first child

      // Since we are giving the next-in-flow our last child, we
      // give it our original mLastContentIsComplete too (in case we
      // are pushing into an empty next-in-flow)
      PushChildren(kidFrame, prevKidFrame, originalLastContentIsComplete);
      SetLastContentOffset(prevKidFrame);

      result = PR_FALSE;
      break;
    }

    // Place the child after taking into account it's margin
    aState.y += topMargin;
    nsRect kidRect (0, 0, kidSize.width, kidSize.height);
    kidRect.x += kidMargin.left;
    kidRect.y += aState.y;
    PlaceChild(aState, kidFrame, kidRect, aMaxElementSize, kidMaxElementSize);
    if (bottomMargin < 0) {
      aState.prevMaxNegBottomMargin = -bottomMargin;
    } else {
      aState.prevMaxPosBottomMargin = bottomMargin;
    }
    childCount++;

    // Remember where we just were in case we end up pushing children
    prevKidFrame = kidFrame;

    // Update mLastContentIsComplete now that this kid fits
    mLastContentIsComplete = NS_FRAME_IS_COMPLETE(status);

    if (NS_FRAME_IS_NOT_COMPLETE(status)) {
      // No, the child isn't complete
      nsIFrame* kidNextInFlow;

      kidFrame->GetNextInFlow(kidNextInFlow);
      PRBool lastContentIsComplete = mLastContentIsComplete;
      if (nsnull == kidNextInFlow) {
        // The child doesn't have a next-in-flow so create a continuing
        // frame. This hooks the child into the flow
        nsIFrame* continuingFrame;
        nsIStyleContext* kidSC;
        kidFrame->GetStyleContext(aPresContext, kidSC);
        kidFrame->CreateContinuingFrame(aPresContext, this, kidSC,
                                        continuingFrame);
        NS_RELEASE(kidSC);
        NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");

        // Add the continuing frame to the sibling list
        nsIFrame* nextSib;
         
        kidFrame->GetNextSibling(nextSib);
        continuingFrame->SetNextSibling(nextSib);
        kidFrame->SetNextSibling(continuingFrame);
        if (nsnull == nextSib) {
          // Assume that the continuation frame we just created is
          // complete, for now. It will get reflowed by our
          // next-in-flow (we are going to push it now)
          lastContentIsComplete = PR_TRUE;
        }
      }

      // We've used up all of our available space so push the remaining
      // children to the next-in-flow
      nsIFrame* nextSibling;
       
      kidFrame->GetNextSibling(nextSibling);
      if (nsnull != nextSibling) {
        PushChildren(nextSibling, kidFrame, lastContentIsComplete);
        /* debug */
        /*
        printf ("having just pushed children, here is the frame hierarchy.\n");
        nsIFrame *p;
        GetGeometricParent(p);
        nsIFrame *root;
        while (nsnull!=p)
        {
          root = p;
          p->GetGeometricParent(p);
        }
        root->List();
        fflush(stdout);
        */
        /* end debug */
        SetLastContentOffset(prevKidFrame);
      }
      result = PR_FALSE;
      break;
    }

    // Get the next child
    kidFrame->GetNextSibling(kidFrame);

    // XXX talk with troy about checking for available space here
  }

  // Update the child count
  mChildCount = childCount;
  NS_POSTCONDITION(LengthOf(mFirstChild) == mChildCount, "bad child count");

  // Set the last content offset based on the last child we mapped.
  NS_ASSERTION(IsLastChild(prevKidFrame), "unexpected last child");
  SetLastContentOffset(prevKidFrame);

#ifdef NS_DEBUG
  VerifyLastIsComplete();
#endif
#ifdef NOISY
  ListTag(stdout);
  printf(": reflow mapped %sok (childCount=%d) [%d,%d,%c]\n",
         (result ? "" : "NOT "),
         mChildCount,
         mFirstContentOffset, mLastContentOffset,
         (mLastContentIsComplete ? 'T' : 'F'));
#ifdef NOISY_FLOW
  {
    nsTableOuterFrame* flow = (nsTableOuterFrame*) mNextInFlow;
    while (flow != 0) {
      printf("  %p: [%d,%d,%c]\n",
             flow, flow->mFirstContentOffset, flow->mLastContentOffset,
             (flow->mLastContentIsComplete ? 'T' : 'F'));
      flow = (nsTableOuterFrame*) flow->mNextInFlow;
    }
  }
#endif
#endif
  return result;
}

/**
 * Try and pull-up frames from our next-in-flow
 *
 * @param   aPresContext presentation context to use
 * @param   aState current inline state
 * @return  true if we successfully pulled-up all the children and false
 *            otherwise, e.g. child didn't fit
 */
PRBool nsTableOuterFrame::PullUpChildren( nsIPresContext*      aPresContext,
                                          OuterTableReflowState& aState,
                                          nsSize*              aMaxElementSize)
{
#ifdef NS_DEBUG
  VerifyLastIsComplete();
#endif
#ifdef NOISY
  ListTag(stdout);
  printf(": pullup (childCount=%d) [%d,%d,%c]\n",
         mChildCount,
         mFirstContentOffset, mLastContentOffset,
         (mLastContentIsComplete ? 'T' : 'F'));
#ifdef NOISY_FLOW
  {
    nsTableOuterFrame* flow = (nsTableOuterFrame*) mNextInFlow;
    while (flow != 0) {
      printf("  %p: [%d,%d,%c]\n",
             flow, flow->mFirstContentOffset, flow->mLastContentOffset,
             (flow->mLastContentIsComplete ? 'T' : 'F'));
      flow = (nsTableOuterFrame*) flow->mNextInFlow;
    }
  }
#endif
#endif
  nsTableOuterFrame* nextInFlow = (nsTableOuterFrame*)mNextInFlow;
  nsSize         kidMaxElementSize(0,0);
  nsSize*        pKidMaxElementSize = (nsnull != aMaxElementSize) ? &kidMaxElementSize : nsnull;
#ifdef NS_DEBUG
  PRInt32        kidIndex = NextChildOffset();
#endif
  nsIFrame*      prevKidFrame;
   
  LastChild(prevKidFrame);

  // This will hold the prevKidFrame's mLastContentIsComplete
  // status. If we have to push the frame that follows prevKidFrame
  // then this will become our mLastContentIsComplete state. Since
  // prevKidFrame is initially our last frame, it's completion status
  // is our mLastContentIsComplete value.
  PRBool        prevLastContentIsComplete = mLastContentIsComplete;

  PRBool        result = PR_TRUE;

  while (nsnull != nextInFlow) {
    nsReflowMetrics   kidSize(pKidMaxElementSize);
    kidSize.width=kidSize.height=kidSize.ascent=kidSize.descent=0;
    nsReflowStatus    status;

    // Get the next child
    nsIFrame* kidFrame = nextInFlow->mFirstChild;

    // Any more child frames?
    if (nsnull == kidFrame) {
      // No. Any frames on its overflow list?
      if (nsnull != nextInFlow->mOverflowList) {
        // Move the overflow list to become the child list
        //NS_ABORT();
        nextInFlow->AppendChildren(nextInFlow->mOverflowList);
        nextInFlow->mOverflowList = nsnull;
        kidFrame = nextInFlow->mFirstChild;
      } else {
        // We've pulled up all the children, so move to the next-in-flow.
        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
        continue;
      }
    }

    // See if the child fits in the available space. If it fits or
    // it's splittable then reflow it. The reason we can't just move
    // it is that we still need ascent/descent information
    nsSize            kidFrameSize(0,0);
    nsSplittableType  kidIsSplittable;

    kidFrame->GetSize(kidFrameSize);
    kidFrame->IsSplittable(kidIsSplittable);

    if ((kidFrameSize.width  > aState.availSize.height) &&
        NS_FRAME_IS_NOT_SPLITTABLE(kidIsSplittable)) {
      result = PR_FALSE;
      mLastContentIsComplete = prevLastContentIsComplete;
      break;
    }
    kidFrame->WillReflow(*aPresContext);
    status = ReflowChild(kidFrame, aPresContext, kidSize, aState.availSize,
                         pKidMaxElementSize, aState);

    // Did the child fit?
    if ((kidSize.height > aState.availSize.height) && (nsnull != mFirstChild)) {
      // The child is too wide to fit in the available space, and it's
      // not our first child
      result = PR_FALSE;
      mLastContentIsComplete = prevLastContentIsComplete;
      break;
    }

    // Place the child after taking into account it's margin
//    aState.y += topMargin;
    nsRect kidRect (0, 0, kidSize.width, kidSize.height);
//    kidRect.x += kidMol->margin.left;
    kidRect.y += aState.y;
    PlaceChild(aState, kidFrame, kidRect, aMaxElementSize, *pKidMaxElementSize);

    // Remove the frame from its current parent
    kidFrame->GetNextSibling(nextInFlow->mFirstChild);
    nextInFlow->mChildCount--;
    // Update the next-in-flows first content offset
    if (nsnull != nextInFlow->mFirstChild) {
      nextInFlow->SetFirstContentOffset(nextInFlow->mFirstChild);
    }

    // Link the frame into our list of children
    kidFrame->SetGeometricParent(this);
    nsIFrame* kidContentParent;

    kidFrame->GetContentParent(kidContentParent);
    if (nextInFlow == kidContentParent) {
      kidFrame->SetContentParent(this);
    }
    if (nsnull == prevKidFrame) {
      mFirstChild = kidFrame;
      SetFirstContentOffset(kidFrame);
    } else {
      prevKidFrame->SetNextSibling(kidFrame);
    }
    kidFrame->SetNextSibling(nsnull);
    mChildCount++;

    // Remember where we just were in case we end up pushing children
    prevKidFrame = kidFrame;
    prevLastContentIsComplete = mLastContentIsComplete;

    // Is the child we just pulled up complete?
    mLastContentIsComplete = NS_FRAME_IS_COMPLETE(status);
    if (NS_FRAME_IS_NOT_COMPLETE(status)) {
      // No the child isn't complete
      nsIFrame* kidNextInFlow;
       
      kidFrame->GetNextInFlow(kidNextInFlow);
      if (nsnull == kidNextInFlow) {
        // The child doesn't have a next-in-flow so create a
        // continuing frame. The creation appends it to the flow and
        // prepares it for reflow.
        nsIFrame* continuingFrame;
        nsIStyleContext* kidSC;
        kidFrame->GetStyleContext(aPresContext, kidSC);
        kidFrame->CreateContinuingFrame(aPresContext, this, kidSC,
                                        continuingFrame);
        NS_ASSERTION(nsnull != continuingFrame, "frame creation failed");

        // Add the continuing frame to our sibling list and then push
        // it to the next-in-flow. This ensures the next-in-flow's
        // content offsets and child count are set properly. Note that
        // we can safely assume that the continuation is complete so
        // we pass PR_TRUE into PushChidren in case our next-in-flow
        // was just drained and now needs to know it's
        // mLastContentIsComplete state.
        kidFrame->SetNextSibling(continuingFrame);

        PushChildren(continuingFrame, kidFrame, PR_TRUE);

        // After we push the continuation frame we don't need to fuss
        // with mLastContentIsComplete beause the continuation frame
        // is no longer on *our* list.
      }

      // If the child isn't complete then it means that we've used up
      // all of our available space.
      result = PR_FALSE;
      break;
    }
  }

  // Update our last content offset
  if (nsnull != prevKidFrame) {
    NS_ASSERTION(IsLastChild(prevKidFrame), "bad last child");
    SetLastContentOffset(prevKidFrame);
  }

  // We need to make sure the first content offset is correct for any empty
  // next-in-flow frames (frames where we pulled up all the child frames)
  nextInFlow = (nsTableOuterFrame*)mNextInFlow;
  if ((nsnull != nextInFlow) && (nsnull == nextInFlow->mFirstChild)) {
    // We have at least one empty frame. Did we succesfully pull up all the
    // child frames?
    if (PR_FALSE == result) {
      // No, so we need to adjust the first content offset of all the empty
      // frames
      AdjustOffsetOfEmptyNextInFlows();
#ifdef NS_DEBUG
    } else {
      // Yes, we successfully pulled up all the child frames which means all
      // the next-in-flows must be empty. Do a sanity check
      while (nsnull != nextInFlow) {
        NS_ASSERTION(nsnull == nextInFlow->mFirstChild, "non-empty next-in-flow");
        nextInFlow->GetNextInFlow((nsIFrame*&)nextInFlow);
      }
#endif
    }
  }

#ifdef NS_DEBUG
  PRInt32 len = LengthOf(mFirstChild);
  NS_ASSERTION(len == mChildCount, "bad child count");
  VerifyLastIsComplete();
#endif
#ifdef NOISY
  ListTag(stdout);
  printf(": pullup %sok (childCount=%d) [%d,%d,%c]\n",
         (result ? "" : "NOT "),
         mChildCount,
         mFirstContentOffset, mLastContentOffset,
         (mLastContentIsComplete ? 'T' : 'F'));
#ifdef NOISY_FLOW
  {
    nsTableOuterFrame* flow = (nsTableOuterFrame*) mNextInFlow;
    while (flow != 0) {
      printf("  %p: [%d,%d,%c]\n",
             flow, flow->mFirstContentOffset, flow->mLastContentOffset,
             (flow->mLastContentIsComplete ? 'T' : 'F'));
      flow = (nsTableOuterFrame*) flow->mNextInFlow;
    }
  }
#endif
#endif
  return result;
}

/** set the OuterTableReflowState based on the child frame we are currently processing.
  * must be called before ReflowChild, at a minimum.
  */
void nsTableOuterFrame::SetReflowState(OuterTableReflowState& aState, nsIFrame* aKidFrame)
{
  nsIContentPtr kid;
   
  aKidFrame->GetContent(kid.AssignRef());                             // kid: REFCNT++
  nsITableContent *tableContentInterface = nsnull;
  kid->QueryInterface(kITableContentIID, (void**)&tableContentInterface);// tableContentInterface: REFCNT++
  if (nsnull!=tableContentInterface)
  {
    aState.processingCaption = PR_TRUE;
    NS_RELEASE(tableContentInterface);                                   // tableContentInterface: REFCNT--
  }
  else
    aState.processingCaption = PR_FALSE;
}

/**
 * Reflow a child frame and return the status of the reflow. If the
 * child is complete and it has next-in-flows (it was a splittable child)
 * then delete the next-in-flows.
 */
nsReflowStatus
nsTableOuterFrame::ReflowChild( nsIFrame*        aKidFrame,
                                nsIPresContext*  aPresContext,
                                nsReflowMetrics& aDesiredSize,
                                const nsSize&    aMaxSize,
                                nsSize*          aMaxElementSize,
                                OuterTableReflowState& aState)
{
  nsReflowStatus status;

  /* call the appropriate reflow method based on the type and position of the child */
  if (PR_TRUE==aState.processingCaption)
  { // it's a caption, find out if it's top or bottom
    // Resolve style
    nsIStyleContextPtr captionStyleContext;

    aKidFrame->GetStyleContext(aPresContext, captionStyleContext.AssignRef());
    NS_ASSERTION(captionStyleContext.IsNotNull(), "null style context for caption");
    const nsStyleText* captionStyle =
      (const nsStyleText*)captionStyleContext->GetStyleData(eStyleStruct_Text);
    NS_ASSERTION(nsnull != captionStyle, "null style molecule for caption");
    if ((eStyleUnit_Enumerated == captionStyle->mVerticalAlign.GetUnit()) && 
        (NS_STYLE_VERTICAL_ALIGN_BOTTOM==captionStyle->mVerticalAlign.GetIntValue()))
    {
      if (PR_TRUE==gsDebug) printf("reflowChild called with a bottom caption\n");
      status = ResizeReflowBottomCaptionsPass2(aPresContext, aDesiredSize,
                                               aMaxSize, aMaxElementSize,
                                               aState.y, aState);
    }
    else
    {
      if (PR_TRUE==gsDebug) printf("reflowChild called with a top caption\n");
      status = ResizeReflowTopCaptionsPass2(aPresContext, aDesiredSize,
                                            aMaxSize, aMaxElementSize, aState);
    }
  }
  else
  {
    if (PR_TRUE==gsDebug) printf("reflowChild called with a table body\n");
    nsReflowState kidReflowState(aKidFrame, aState.reflowState, aState.innerTableMaxSize);
    status = ((nsTableFrame*)aKidFrame)->ResizeReflowPass2(aPresContext, aDesiredSize, kidReflowState, 
                                                           mMinCaptionWidth, mMaxCaptionWidth);
  }
  if (PR_TRUE==gsDebug)
  {
  }

  if (NS_FRAME_IS_COMPLETE(status)) {
    nsIFrame* kidNextInFlow;
     
    aKidFrame->GetNextInFlow(kidNextInFlow);
    if (nsnull != kidNextInFlow) {
      // Remove all of the childs next-in-flows. Make sure that we ask
      // the right parent to do the removal (it's possible that the
      // parent is not this because we are executing pullup code)
      nsTableOuterFrame* parent;
       
      aKidFrame->GetGeometricParent((nsIFrame*&)parent);
      parent->DeleteChildsNextInFlow(aKidFrame);
    }
  }
  return status;
}

void nsTableOuterFrame::CreateChildFrames(nsIPresContext*  aPresContext)
{
  nsIFrame *prevKidFrame = nsnull;
  nsresult frameCreated = nsTableFrame::NewFrame((nsIFrame **)(&mInnerTableFrame), mContent, this);
  if (NS_OK!=frameCreated)
    return;  // SEC: an error!!!!
  // Resolve style
  nsIStyleContextPtr kidStyleContext =
    aPresContext->ResolveStyleContextFor(mContent, this);
  NS_ASSERTION(kidStyleContext.IsNotNull(), "bad style context for kid.");
  mInnerTableFrame->SetStyleContext(aPresContext,kidStyleContext);
  mChildCount++;
  // Link child frame into the list of children
  mFirstChild = mInnerTableFrame;
  prevKidFrame = mInnerTableFrame;

  // now create the caption frames, prepending top captions and
  // appending bottom captions
  mCaptionFrames = new nsVoidArray();
  // create caption frames as needed
  nsIFrame *lastTopCaption = nsnull;
  for (PRInt32 kidIndex=0; /* nada */ ;kidIndex++) {
    nsIContentPtr caption = mContent->ChildAt(kidIndex);   // caption: REFCNT++
    if (caption.IsNull()) {
      break;
    }
    const PRInt32 contentType = ((nsTableContent *)(nsIContent*)caption)->GetType();
    if (contentType==nsITableContent::kTableCaptionType)
    {
      // Resolve style
      nsIStyleContextPtr captionStyleContext =
        aPresContext->ResolveStyleContextFor(caption, this);
      NS_ASSERTION(captionStyleContext.IsNotNull(), "bad style context for caption.");
      const nsStyleText* captionStyle = 
        (const nsStyleText*)captionStyleContext->GetStyleData(eStyleStruct_Text);
      // create the frame
      nsIFrame *captionFrame=nsnull;
      frameCreated = ((nsIHTMLContent*)(nsIContent*)caption)->CreateFrame(aPresContext, 
                      this, captionStyleContext, captionFrame);
      if (NS_OK!=frameCreated)
        return;  // SEC: an error!!!!

      mChildCount++;
      // Link child frame into the list of children
      if ((eStyleUnit_Enumerated == captionStyle->mVerticalAlign.GetUnit()) && 
          (NS_STYLE_VERTICAL_ALIGN_BOTTOM==captionStyle->mVerticalAlign.GetIntValue()))
      { // bottom captions get added to the end of the outer frame child list
        prevKidFrame->SetNextSibling(captionFrame);
        prevKidFrame = captionFrame;
        // bottom captions get remembered in an instance variable for easy access later
        if (nsnull==mBottomCaptions)
        {
          mBottomCaptions = new nsVoidArray();
        }
        mBottomCaptions->AppendElement(captionFrame);
      }
      else
      {  // top captions get prepended to the outer frame child list
        if (nsnull == lastTopCaption) 
        { // our first top caption, therefore our first child
          mFirstChild = captionFrame;
          mFirstChild->SetNextSibling(mInnerTableFrame);
        }
        else 
        { // just another grub in the brood of top captions
          lastTopCaption->SetNextSibling(captionFrame);
          lastTopCaption = captionFrame;
        }
        lastTopCaption = captionFrame;
      }
      mCaptionFrames->AppendElement(captionFrame);
    }
    else
    {
      break;
    }
  }
}


nsReflowStatus
nsTableOuterFrame::ResizeReflowCaptionsPass1(nsIPresContext* aPresContext,
                                             OuterTableReflowState& aState)
{
  if (nsnull!=mCaptionFrames)
  {
    PRInt32 numCaptions = mCaptionFrames->Count();
    for (PRInt32 captionIndex = 0; captionIndex < numCaptions; captionIndex++)
    {
      nsSize maxElementSize(0,0);
      nsSize maxSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
      nsReflowMetrics kidSize(&maxElementSize);
      kidSize.width=kidSize.height=kidSize.ascent=kidSize.descent=0;
      nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);
      nsReflowStatus  status;
      nsReflowState   reflowState(captionFrame, aState.reflowState, maxSize, eReflowReason_Resize);
      captionFrame->WillReflow(*aPresContext);
      captionFrame->Reflow(aPresContext, kidSize, reflowState, status);
      if (mMinCaptionWidth<maxElementSize.width)
        mMinCaptionWidth = maxElementSize.width;
      if (mMaxCaptionWidth<kidSize.width)
        mMaxCaptionWidth = kidSize.width;
      captionFrame->VerticallyAlignChild(aPresContext);

    }
  }
  return NS_FRAME_COMPLETE;
}

nsReflowStatus
nsTableOuterFrame::ResizeReflowTopCaptionsPass2(nsIPresContext*        aPresContext,
                                                nsReflowMetrics&       aDesiredSize,
                                                const nsSize&          aMaxSize,
                                                nsSize*                aMaxElementSize,
                                                OuterTableReflowState& aState)
{
  nsReflowStatus result = NS_FRAME_COMPLETE;
  nscoord topCaptionY = 0;
  if (nsnull!=mCaptionFrames)
  {
    PRInt32 numCaptions = mCaptionFrames->Count();
    for (PRInt32 captionIndex = 0; captionIndex < numCaptions; captionIndex++)
    {
      // get the caption
      nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mCaptionFrames->ElementAt(captionIndex);

      // Resolve style
      nsIStyleContextPtr captionStyleContext;
       
      captionFrame->GetStyleContext(aPresContext, captionStyleContext.AssignRef());
      NS_ASSERTION(captionStyleContext.IsNotNull(), "null style context for caption");
      const nsStyleText* captionStyle =
        (const nsStyleText*)captionStyleContext->GetStyleData(eStyleStruct_Text);
      NS_ASSERTION(nsnull != captionStyle, "null style molecule for caption");

      if ((eStyleUnit_Enumerated == captionStyle->mVerticalAlign.GetUnit()) && 
          (NS_STYLE_VERTICAL_ALIGN_BOTTOM==captionStyle->mVerticalAlign.GetIntValue()))
      { 
      }
      else
      { // top-align captions, the default
        // reflow the caption, skipping top captions after the first that doesn't fit
        if (NS_FRAME_IS_COMPLETE(result))
        {
          nsReflowMetrics desiredSize(nsnull);
          desiredSize.width=desiredSize.height=desiredSize.ascent=desiredSize.descent=0;
          nsReflowState   reflowState(captionFrame, aState.reflowState, aMaxSize, eReflowReason_Resize);
          captionFrame->WillReflow(*aPresContext);
          result = nsContainerFrame::ReflowChild(captionFrame, aPresContext, desiredSize, reflowState);
          // place the caption
          captionFrame->SetRect(nsRect(0, topCaptionY, desiredSize.width, desiredSize.height));
          if (NS_UNCONSTRAINEDSIZE!=desiredSize.height)
            topCaptionY += desiredSize.height;
          else
            topCaptionY = NS_UNCONSTRAINEDSIZE;
          mInnerTableFrame->MoveTo(0, topCaptionY);
          PRInt32 captionIndexInParent;

          captionFrame->GetContentIndex(captionIndexInParent);
          if (0==captionIndexInParent)
          {
            SetFirstContentOffset(captionFrame);
            if (gsDebug) printf("OUTER: set first content offset to %d\n", GetFirstContentOffset()); //@@@
          }
        }
        // else continue on, so we can build the mBottomCaptions list
      }
    }
  }
  aDesiredSize.width = aMaxSize.width;
  aDesiredSize.height = topCaptionY;
  if (nsnull!=aMaxElementSize)
  { // SEC: this isn't right
    aMaxElementSize->width = aMaxSize.width;
    aMaxElementSize->height = topCaptionY;
  }
  return result;
}

nsReflowStatus
nsTableOuterFrame::ResizeReflowBottomCaptionsPass2(nsIPresContext*  aPresContext,
                                                   nsReflowMetrics& aDesiredSize,
                                                   const nsSize&    aMaxSize,
                                                   nsSize*          aMaxElementSize,
                                                   nscoord          aYOffset,
                                                   OuterTableReflowState& aState)
{
  nsReflowStatus result = NS_FRAME_COMPLETE;
  nscoord bottomCaptionY = aYOffset;
  // for now, assume all captions are stacked vertically
  if (nsnull!=mBottomCaptions)
  {
    PRInt32 numCaptions = mBottomCaptions->Count();
    for (PRInt32 captionIndex = 0; captionIndex < numCaptions; captionIndex++)
    {
      // get the caption
      nsTableCaptionFrame *captionFrame = (nsTableCaptionFrame *)mBottomCaptions->ElementAt(captionIndex);

      // Resolve style
/*
      nsIStyleContextPtr captionStyleContext = captionFrame->GetStyleContext(aPresContext);
      NS_ASSERTION(nsnull != captionStyleContext, "null style context for caption");
      nsStyleMolecule* captionStyle =
        (nsStyleMolecule*)captionStyleContext->GetData(eStyleStruct_Molecule);
      NS_ASSERTION(nsnull != captionStyle, "null style molecule for caption");
*/
      // reflow the caption
      nsReflowMetrics desiredSize(nsnull);
      desiredSize.width=desiredSize.height=desiredSize.ascent=desiredSize.descent=0;
      nsReflowState   reflowState(captionFrame, aState.reflowState, aMaxSize, eReflowReason_Resize);
      captionFrame->WillReflow(*aPresContext);
      result = nsContainerFrame::ReflowChild(captionFrame, aPresContext, desiredSize, reflowState);

      // place the caption
      nsRect rect;
       
      captionFrame->GetRect(rect);
      rect.y = bottomCaptionY;
      rect.width=desiredSize.width;
      rect.height=desiredSize.height;
      captionFrame->SetRect(rect);
      if (NS_UNCONSTRAINEDSIZE!=desiredSize.height)
        bottomCaptionY += desiredSize.height;
      else
        bottomCaptionY = NS_UNCONSTRAINEDSIZE;
    }
  }
  aDesiredSize.width = aMaxSize.width;
  aDesiredSize.height = bottomCaptionY-aYOffset;
  if (nsnull!=aMaxElementSize)
  { // SEC: not right
    aMaxElementSize->width = aMaxSize.width;
    aMaxElementSize->height = bottomCaptionY-aYOffset;
  }
  return result;
}

/**
 * Sets the last content offset based on the last child frame. If the last
 * child is a pseudo frame then it sets mLastContentIsComplete to be the same
 * as the last child's mLastContentIsComplete
 */
/*
void nsTableOuterFrame::SetLastContentOffset(const nsIFrame* aLastChild)
{
  NS_PRECONDITION(nsnull != aLastChild, "bad argument");
  NS_PRECONDITION(aLastChild->GetGeometricParent() == this, "bad geometric parent");

  if (ChildIsPseudoFrame(aLastChild)) {
    nsContainerFrame* pseudoFrame = (nsContainerFrame*)aLastChild;
    mLastContentOffset = pseudoFrame->GetLastContentOffset();
    mLastContentIsComplete = pseudoFrame->GetLastContentIsComplete();
  } else {
    mLastContentOffset = aLastChild->GetIndexInParent();
  }
#ifdef NS_DEBUG
  if (mLastContentOffset < mFirstContentOffset) {
    nsIFrame* top = this;
    while (top->GetGeometricParent() != nsnull) {
      top = top->GetGeometricParent();
    }
    top->List();
  }
#endif
  // it is this next line that forces us to re-implement this method here
  //NS_ASSERTION(mLastContentOffset >= mFirstContentOffset, "unexpected content mapping");
}
*/

NS_METHOD
nsTableOuterFrame::CreateContinuingFrame(nsIPresContext*  aPresContext,
                                         nsIFrame*        aParent,
                                         nsIStyleContext* aStyleContext,
                                         nsIFrame*&       aContinuingFrame)
{
  nsTableOuterFrame* cf = new nsTableOuterFrame(mContent, aParent);
  if (nsnull == cf) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  PrepareContinuingFrame(aPresContext, aParent, aStyleContext, cf);
  cf->SetFirstPassValid(PR_TRUE);
  if (PR_TRUE==gsDebug)
    printf("nsTableOuterFrame::CCF parent = %p, this=%p, cf=%p\n", aParent, this, cf);
  aContinuingFrame = cf;
  return NS_OK;
}

void
nsTableOuterFrame::PrepareContinuingFrame(nsIPresContext*    aPresContext,
                                          nsIFrame*          aParent,
                                          nsIStyleContext*   aStyleContext,
                                          nsTableOuterFrame* aContFrame)
{
  // Append the continuing frame to the flow
  aContFrame->AppendToFlow(this);

  // Initialize it's content offsets. Note that we assume for now that
  // the continuingFrame will map the remainder of the content and
  // that therefore mLastContentIsComplete will be true.
  PRInt32 nextOffset;
  if (mChildCount > 0) {
    nextOffset = mLastContentOffset;
    if (mLastContentIsComplete) {
      nextOffset++;
    }
  } else {
    nextOffset = mFirstContentOffset;
  }

  aContFrame->SetFirstContentOffset(nextOffset);
  aContFrame->SetLastContentOffset(nextOffset);
  aContFrame->SetLastContentIsComplete(PR_TRUE);
  aContFrame->SetStyleContext(aPresContext, aStyleContext);
}

NS_METHOD nsTableOuterFrame::VerifyTree() const
{
#ifdef NS_DEBUG
  
#endif 
  return NS_OK;
}

/**
 * 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
 */
PRBool nsTableOuterFrame::DeleteChildsNextInFlow(nsIFrame* aChild)
{
  NS_PRECONDITION(IsChild(aChild), "bad geometric parent");

  nsIFrame* nextInFlow;
   
  aChild->GetNextInFlow(nextInFlow);

  NS_PRECONDITION(nsnull != nextInFlow, "null next-in-flow");
  nsTableOuterFrame* parent;
   
  nextInFlow->GetGeometricParent((nsIFrame*&)parent);

  // If the next-in-flow has a next-in-flow then delete it too (and
  // delete it first).
  nsIFrame* nextNextInFlow;

  nextInFlow->GetNextInFlow(nextNextInFlow);
  if (nsnull != nextNextInFlow) {
    parent->DeleteChildsNextInFlow(nextInFlow);
  }

#ifdef NS_DEBUG
  PRInt32   childCount;
  nsIFrame* firstChild;

  nextInFlow->ChildCount(childCount);
  nextInFlow->FirstChild(firstChild);

  NS_ASSERTION(childCount == 0, "deleting !empty next-in-flow");

  NS_ASSERTION((0 == childCount) && (nsnull == firstChild), "deleting !empty next-in-flow");
#endif

  // Disconnect the next-in-flow from the flow list
  nextInFlow->BreakFromPrevFlow();

  // Take the next-in-flow out of the parent's child list
  if (parent->mFirstChild == nextInFlow) {
    nextInFlow->GetNextSibling(parent->mFirstChild);
    if (nsnull != parent->mFirstChild) {
      parent->SetFirstContentOffset(parent->mFirstChild);
      if (parent->IsPseudoFrame()) {
        parent->PropagateContentOffsets();
      }
    }

    // When a parent loses it's last child and that last child is a
    // pseudo-frame then the parent's content offsets are now wrong.
    // However, we know that the parent will eventually be reflowed
    // in one of two ways: it will either get a chance to pullup
    // children or it will be deleted because it's prev-in-flow
    // (e.g. this) is complete. In either case, the content offsets
    // will be repaired.

  } else {
    nsIFrame* nextSibling;

    // Because the next-in-flow is not the first child of the parent
    // we know that it shares a parent with aChild. Therefore, we need
    // to capture the next-in-flow's next sibling (in case the
    // next-in-flow is the last next-in-flow for aChild AND the
    // next-in-flow is not the last child in parent)
    NS_ASSERTION(parent->IsChild(aChild), "screwy flow");
    aChild->GetNextSibling(nextSibling);
    NS_ASSERTION(nextSibling == nextInFlow, "unexpected sibling");

    nextInFlow->GetNextSibling(nextSibling);
    aChild->SetNextSibling(nextSibling);
  }

  // Delete the next-in-flow frame and adjust it's parent's child count
  nextInFlow->DeleteFrame();
  parent->mChildCount--;

#ifdef NS_DEBUG
  aChild->GetNextInFlow(nextInFlow);
  NS_POSTCONDITION(nsnull == nextInFlow, "non null next-in-flow");
#endif

  return PR_TRUE;
}


void nsTableOuterFrame::CreateInnerTableFrame(nsIPresContext* aPresContext)
{
  // Do we have a prev-in-flow?
  if (nsnull == mPrevInFlow) {
    // No, create a column pseudo frame
    mInnerTableFrame = new nsTableFrame(mContent, this);
    mChildCount++;

    // Resolve style and set the style context
    nsIStyleContextPtr styleContext =
      aPresContext->ResolveStyleContextFor(mContent, this);
    mInnerTableFrame->SetStyleContext(aPresContext,styleContext);
  } else {
    nsTableOuterFrame*  prevOuterTable = (nsTableOuterFrame*)mPrevInFlow;

    nsIFrame* prevInnerTable = prevOuterTable->mInnerTableFrame;

    // Create a continuing column
    prevInnerTable->GetNextInFlow((nsIFrame*&)mInnerTableFrame);
    if (nsnull==mInnerTableFrame)
    {
      nsIFrame* continuingFrame;
      nsIStyleContext* kidSC;
      prevInnerTable->GetStyleContext(aPresContext, kidSC);
      prevInnerTable->CreateContinuingFrame(aPresContext, this, kidSC,
                                            continuingFrame);
      mInnerTableFrame = (nsTableFrame*)continuingFrame;
      mChildCount++;
    }
  }
}

/* ----- static methods ----- */

nsresult nsTableOuterFrame::NewFrame(nsIFrame** aInstancePtrResult,
                                    nsIContent* aContent,
                                    nsIFrame*   aParent)
{
  NS_PRECONDITION(nsnull != aInstancePtrResult, "null ptr");
  if (nsnull == aInstancePtrResult) {
    return NS_ERROR_NULL_POINTER;
  }
  nsIFrame* it = new nsTableOuterFrame(aContent, aParent);
  if (nsnull == it) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  *aInstancePtrResult = it;
  return NS_OK;
}