/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsTableFrame_h__

#define nsTableFrame_h__

#include "mozilla/Attributes.h"

#include "celldata.h"

#include "imgIContainer.h"

#include "nscore.h"

#include "nsContainerFrame.h"

#include "nsStyleCoord.h"

#include "nsStyleConsts.h"

#include "nsCellMap.h"

#include "nsGkAtoms.h"

#include "nsDisplayList.h"

#include "TableArea.h"

struct BCPaintBorderAction;

class nsTableCellFrame;

class nsTableCellMap;

class nsTableColFrame;

class nsTableRowGroupFrame;

class nsTableRowFrame;

class nsTableColGroupFrame;

class nsITableLayoutStrategy;

namespace mozilla {

class WritingMode;

class LogicalMargin;

struct TableReflowInput;

namespace layers {

class StackingContextHelper;

}

} // namespace mozilla

struct BCPropertyData;

static inline bool

IsTableCell(mozilla::LayoutFrameType frameType)

{

  return frameType == mozilla::LayoutFrameType::TableCell ||

         frameType == mozilla::LayoutFrameType::BCTableCell;

}

Unexecuted instantiation: Unified_cpp_dom_base4.cpp:IsTableCell(mozilla::LayoutFrameType)

Unexecuted instantiation: Unified_cpp_accessible_generic0.cpp:IsTableCell(mozilla::LayoutFrameType)

class nsDisplayTableItem : public nsDisplayItem

{

public:

  nsDisplayTableItem(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,

                     bool aDrawsBackground = true) :

      nsDisplayItem(aBuilder, aFrame),

      mPartHasFixedBackground(false),

      mDrawsBackground(aDrawsBackground) {}

  // With collapsed borders, parts of the collapsed border can extend outside

  // the table part frames, so allow this display element to blow out to our

  // overflow rect. This is also useful for row frames that have spanning

  // cells extending outside them.

  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,

                           bool* aSnap) const override;

  virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;

  virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,

                                         const nsDisplayItemGeometry* aGeometry,

                                         nsRegion *aInvalidRegion) const override;

  void UpdateForFrameBackground(nsIFrame* aFrame);

private:

  bool mPartHasFixedBackground;

  bool mDrawsBackground;

};

class nsAutoPushCurrentTableItem

{

public:

  nsAutoPushCurrentTableItem()

    : mBuilder(nullptr)

    , mOldCurrentItem(nullptr) {}

  void Push(nsDisplayListBuilder* aBuilder, nsDisplayTableItem* aPushItem)

  {

    mBuilder = aBuilder;

    mOldCurrentItem = aBuilder->GetCurrentTableItem();

    aBuilder->SetCurrentTableItem(aPushItem);

#ifdef DEBUG

    mPushedItem = aPushItem;

#endif

  }

  ~nsAutoPushCurrentTableItem() {

    if (!mBuilder)

      return;

#ifdef DEBUG

    NS_ASSERTION(mBuilder->GetCurrentTableItem() == mPushedItem,

                 "Someone messed with the current table item behind our back!");

#endif

    mBuilder->SetCurrentTableItem(mOldCurrentItem);

  }

private:

  nsDisplayListBuilder* mBuilder;

  nsDisplayTableItem*   mOldCurrentItem;

#ifdef DEBUG

  nsDisplayTableItem*   mPushedItem;

#endif

};

/* ============================================================================ */

enum nsTableColType {

  eColContent            = 0, // there is real col content associated

  eColAnonymousCol       = 1, // the result of a span on a col

  eColAnonymousColGroup  = 2, // the result of a span on a col group

  eColAnonymousCell      = 3  // the result of a cell alone

};

/**

  * nsTableFrame maps the inner portion of a table (everything except captions.)

  * Used as a pseudo-frame within nsTableWrapperFrame, it may also be used

  * stand-alone as the top-level frame.

  *

  * The principal child list contains row group frames. There is also an

  * additional child list, kColGroupList, which contains the col group frames.

  */

class nsTableFrame : public nsContainerFrame

{

  typedef mozilla::image::ImgDrawResult ImgDrawResult;

  typedef mozilla::WritingMode WritingMode;

  typedef mozilla::LogicalMargin LogicalMargin;

  typedef mozilla::TableReflowInput TableReflowInput;

public:

  NS_DECL_FRAMEARENA_HELPERS(nsTableFrame)

  typedef nsTArray<nsIFrame*> FrameTArray;

  NS_DECLARE_FRAME_PROPERTY_DELETABLE(PositionedTablePartArray, FrameTArray)

  /** nsTableWrapperFrame has intimate knowledge of the inner table frame */

  friend class nsTableWrapperFrame;

  /** instantiate a new instance of nsTableRowFrame.

    * @param aPresShell the pres shell for this frame

    *

    * @return           the frame that was created

    */

  friend nsTableFrame* NS_NewTableFrame(nsIPresShell* aPresShell,

                                        ComputedStyle* aStyle);

  /** sets defaults for table-specific style.

    * @see nsIFrame::Init

    */

  virtual void Init(nsIContent*       aContent,

                    nsContainerFrame* aParent,

                    nsIFrame*         aPrevInFlow) override;

  static float GetTwipsToPixels(nsPresContext* aPresContext);

  // Return true if aParentReflowInput.frame or any of its ancestors within

  // the containing table have non-auto bsize. (e.g. pct or fixed bsize)

  static bool AncestorsHaveStyleBSize(const ReflowInput& aParentReflowInput);

  // See if a special bsize reflow will occur due to having a pct bsize when

  // the pct bsize basis may not yet be valid.

  static void CheckRequestSpecialBSizeReflow(const ReflowInput& aReflowInput);

  // Notify the frame and its ancestors (up to the containing table) that a special

  // height reflow will occur.

  static void RequestSpecialBSizeReflow(const ReflowInput& aReflowInput);

  static void RePositionViews(nsIFrame* aFrame);

  static bool PageBreakAfter(nsIFrame* aSourceFrame,

                               nsIFrame* aNextFrame);

  // Register a positioned table part with its nsTableFrame. These objects will

  // be visited by FixupPositionedTableParts after reflow is complete. (See that

  // function for more explanation.) Should be called during frame construction.

  static void RegisterPositionedTablePart(nsIFrame* aFrame);

  // Unregister a positioned table part with its nsTableFrame.

  static void UnregisterPositionedTablePart(nsIFrame* aFrame,

                                            nsIFrame* aDestructRoot);

  nsPoint GetFirstSectionOrigin(const ReflowInput& aReflowInput) const;

  /*

   * Notification that rowspan or colspan has changed for content inside a

   * table cell

   */

  void RowOrColSpanChanged(nsTableCellFrame* aCellFrame);

  /** @see nsIFrame::DestroyFrom */

  virtual void DestroyFrom(nsIFrame* aDestructRoot, PostDestroyData& aPostDestroyData) override;

  /** @see nsIFrame::DidSetComputedStyle */

  virtual void DidSetComputedStyle(ComputedStyle* aOldComputedStyle) override;

  virtual void SetInitialChildList(ChildListID     aListID,

                                   nsFrameList&    aChildList) override;

  virtual void AppendFrames(ChildListID     aListID,

                            nsFrameList&    aFrameList) override;

  virtual void InsertFrames(ChildListID     aListID,

                            nsIFrame*       aPrevFrame,

                            nsFrameList&    aFrameList) override;

  virtual void RemoveFrame(ChildListID     aListID,

                           nsIFrame*       aOldFrame) override;

  virtual nsMargin GetUsedBorder() const override;

  virtual nsMargin GetUsedPadding() const override;

  virtual nsMargin GetUsedMargin() const override;

  // Get the offset from the border box to the area where the row groups fit

  LogicalMargin GetChildAreaOffset(const WritingMode aWM,

                                   const ReflowInput* aReflowInput) const;

  /** helper method to find the table parent of any table frame object */

  static nsTableFrame* GetTableFrame(nsIFrame* aSourceFrame);

  /* Like GetTableFrame, but will set *aDidPassThrough to false if we don't

   * pass through aMustPassThrough on the way to the table.

   */

  static nsTableFrame* GetTableFramePassingThrough(nsIFrame* aMustPassThrough,

                                                   nsIFrame* aSourceFrame,

                                                   bool* aDidPassThrough);

  typedef void (* DisplayGenericTablePartTraversal)

      (nsDisplayListBuilder* aBuilder, nsFrame* aFrame,

       const nsDisplayListSet& aLists);

  static void GenericTraversal(nsDisplayListBuilder* aBuilder, nsFrame* aFrame,

                               const nsDisplayListSet& aLists);

  /**

   * Helper method to handle display common to table frames, rowgroup frames

   * and row frames. It creates a background display item for handling events

   * if necessary, an outline display item if necessary, and displays

   * all the the frame's children.

   * @param aDisplayItem the display item created for this part, or null

   * if this part's border/background painting is delegated to an ancestor

   * @param aTraversal a function that gets called to traverse the table

   * part's child frames and add their display list items to a

   * display list set.

   */

  static void DisplayGenericTablePart(nsDisplayListBuilder* aBuilder,

                                      nsFrame* aFrame,

                                      const nsDisplayListSet& aLists,

                                      DisplayGenericTablePartTraversal aTraversal = GenericTraversal);

  // Return the closest sibling of aPriorChildFrame (including aPriroChildFrame)

  // of type aChildType.

  static nsIFrame* GetFrameAtOrBefore(nsIFrame* aParentFrame,

                                      nsIFrame* aPriorChildFrame,

                                      mozilla::LayoutFrameType aChildType);

  bool IsAutoBSize(mozilla::WritingMode aWM);

  /** @return true if aDisplayType represents a rowgroup of any sort

    * (header, footer, or body)

    */

  bool IsRowGroup(mozilla::StyleDisplay aDisplayType) const;

  virtual const nsFrameList& GetChildList(ChildListID aListID) const override;

  virtual void GetChildLists(nsTArray<ChildList>* aLists) const override;

  virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                                const nsDisplayListSet& aLists) override;

  /** Get the outer half (i.e., the part outside the height and width of

   *  the table) of the largest segment (?) of border-collapsed border on

   *  the table on each side, or 0 for non border-collapsed tables.

   */

  LogicalMargin GetOuterBCBorder(const WritingMode aWM) const;

  /** Same as above, but only if it's included from the border-box width

   *  of the table.

   */

  LogicalMargin GetIncludedOuterBCBorder(const WritingMode aWM) const;

  /** Same as above, but only if it's excluded from the border-box width

   *  of the table.  This is the area that leaks out into the margin

   *  (or potentially past it, if there is no margin).

   */

  LogicalMargin GetExcludedOuterBCBorder(const WritingMode aWM) const;

  /**

   * In quirks mode, the size of the table background is reduced

   * by the outer BC border. Compute the reduction needed.

   */

  nsMargin GetDeflationForBackground(nsPresContext* aPresContext) const;

  /** Get width of table + colgroup + col collapse: elements that

   *  continue along the length of the whole iStart side.

   *  see nsTablePainter about continuous borders

   */

  nscoord GetContinuousIStartBCBorderWidth() const;

  void SetContinuousIStartBCBorderWidth(nscoord aValue);

  friend class nsDelayedCalcBCBorders;

  void AddBCDamageArea(const mozilla::TableArea& aValue);

  bool BCRecalcNeeded(ComputedStyle* aOldComputedStyle,

                        ComputedStyle* aNewComputedStyle);

  void PaintBCBorders(DrawTarget& aDrawTarget, const nsRect& aDirtyRect);

  void CreateWebRenderCommandsForBCBorders(mozilla::wr::DisplayListBuilder& aBuilder,

                                           const mozilla::layers::StackingContextHelper& aSc,

                                           const nsRect& aVisibleRect,

                                           const nsPoint& aOffsetToReferenceFrame);

  virtual void MarkIntrinsicISizesDirty() override;

  // For border-collapse tables, the caller must not add padding and

  // border to the results of these functions.

  virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;

  virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;

  IntrinsicISizeOffsetData IntrinsicISizeOffsets(nscoord aPercentageBasis =

                                                 NS_UNCONSTRAINEDSIZE) override;

  virtual mozilla::LogicalSize

  ComputeSize(gfxContext*                 aRenderingContext,

              mozilla::WritingMode        aWM,

              const mozilla::LogicalSize& aCBSize,

              nscoord                     aAvailableISize,

              const mozilla::LogicalSize& aMargin,

              const mozilla::LogicalSize& aBorder,

              const mozilla::LogicalSize& aPadding,

              ComputeSizeFlags            aFlags) override;

  virtual mozilla::LogicalSize

  ComputeAutoSize(gfxContext*                 aRenderingContext,

                  mozilla::WritingMode        aWM,

                  const mozilla::LogicalSize& aCBSize,

                  nscoord                     aAvailableISize,

                  const mozilla::LogicalSize& aMargin,

                  const mozilla::LogicalSize& aBorder,

                  const mozilla::LogicalSize& aPadding,

                  ComputeSizeFlags            aFlags) override;

  /**

   * A copy of nsFrame::ShrinkWidthToFit that calls a different

   * GetPrefISize, since tables have two different ones.

   */

  nscoord TableShrinkISizeToFit(gfxContext *aRenderingContext,

                                nscoord aWidthInCB);

  // XXXldb REWRITE THIS COMMENT!

  /** inner tables are reflowed in two steps.

    * <pre>

    * if mFirstPassValid is false, this is our first time through since content was last changed

    *   set pass to 1

    *   do pass 1

    *     get min/max info for all cells in an infinite space

    *   do column balancing

    *   set mFirstPassValid to true

    *   do pass 2

    *     use column widths to Reflow cells

    * </pre>

    *

    * @see nsIFrame::Reflow

    */

  virtual void Reflow(nsPresContext*           aPresContext,

                      ReflowOutput&     aDesiredSize,

                      const ReflowInput& aReflowInput,

                      nsReflowStatus&          aStatus) override;

  void ReflowTable(ReflowOutput&     aDesiredSize,

                   const ReflowInput& aReflowInput,

                   nscoord                  aAvailBSize,

                   nsIFrame*&               aLastChildReflowed,

                   nsReflowStatus&          aStatus);

  nsFrameList& GetColGroups();

  virtual ComputedStyle*

  GetParentComputedStyle(nsIFrame** aProviderFrame) const override;

  virtual bool IsFrameOfType(uint32_t aFlags) const override

  {

    if (aFlags & eSupportsCSSTransforms) {

      return false;

    }

    return nsContainerFrame::IsFrameOfType(aFlags);

  }

#ifdef DEBUG_FRAME_DUMP

  /** @see nsIFrame::GetFrameName */

  virtual nsresult GetFrameName(nsAString& aResult) const override;

#endif

  /** Return the isize of the column at aColIndex.

   *  This may only be called on the table's first-in-flow.

   */

  nscoord GetColumnISizeFromFirstInFlow(int32_t aColIndex);

  /** Helper to get the column spacing style value.

   *  The argument refers to the space between column aColIndex and column

   *  aColIndex + 1.  An index of -1 indicates the padding between the table

   *  and the left border, an index equal to the number of columns indicates

   *  the padding between the table and the right border.

   *

   *  Although in this class cell spacing does not depend on the index, it

   *  may be important for overriding classes.

   */

  virtual nscoord GetColSpacing(int32_t aColIndex);

  /** Helper to find the sum of the cell spacing between arbitrary columns.

   *  The argument refers to the space between column aColIndex and column

   *  aColIndex + 1.  An index of -1 indicates the padding between the table

   *  and the left border, an index equal to the number of columns indicates

   *  the padding between the table and the right border.

   *

   *  This method is equivalent to

   *  nscoord result = 0;

   *  for (i = aStartColIndex; i < aEndColIndex; i++) {

   *    result += GetColSpacing(i);

   *  }

   *  return result;

   */

  virtual nscoord GetColSpacing(int32_t aStartColIndex,

                                int32_t aEndColIndex);

  /** Helper to get the row spacing style value.

   *  The argument refers to the space between row aRowIndex and row

   *  aRowIndex + 1.  An index of -1 indicates the padding between the table

   *  and the top border, an index equal to the number of rows indicates

   *  the padding between the table and the bottom border.

   *

   *  Although in this class cell spacing does not depend on the index, it

   *  may be important for overriding classes.

   */

  virtual nscoord GetRowSpacing(int32_t aRowIndex);

  /** Helper to find the sum of the cell spacing between arbitrary rows.

   *  The argument refers to the space between row aRowIndex and row

   *  aRowIndex + 1.  An index of -1 indicates the padding between the table

   *  and the top border, an index equal to the number of rows indicates

   *  the padding between the table and the bottom border.

   *

   *  This method is equivalent to

   *  nscoord result = 0;

   *  for (i = aStartRowIndex; i < aEndRowIndex; i++) {

   *    result += GetRowSpacing(i);

   *  }

   *  return result;

   */

  virtual nscoord GetRowSpacing(int32_t aStartRowIndex,

                                  int32_t aEndRowIndex);

private:

  /* For the base implementation of nsTableFrame, cell spacing does not depend

   * on row/column indexing.

   */

  nscoord GetColSpacing();

  nscoord GetRowSpacing();

public:

  virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override;

  bool GetNaturalBaselineBOffset(mozilla::WritingMode aWM,

                                 BaselineSharingGroup aBaselineGroup,

                                 nscoord*             aBaseline) const override;

  /** return the row span of a cell, taking into account row span magic at the bottom

    * of a table. The row span equals the number of rows spanned by aCell starting at

    * aStartRowIndex, and can be smaller if aStartRowIndex is greater than the row

    * index in which aCell originates.

    *

    * @param aStartRowIndex the cell

    * @param aCell          the cell

    *

    * @return  the row span, correcting for row spans that extend beyond the bottom

    *          of the table.

    */

  int32_t  GetEffectiveRowSpan(int32_t                 aStartRowIndex,

                               const nsTableCellFrame& aCell) const;

  int32_t  GetEffectiveRowSpan(const nsTableCellFrame& aCell,

                               nsCellMap*              aCellMap = nullptr);

  /** return the col span of a cell, taking into account col span magic at the edge

    * of a table.

    *

    * @param aCell      the cell

    *

    * @return  the col span, correcting for col spans that extend beyond the edge

    *          of the table.

    */

  int32_t  GetEffectiveColSpan(const nsTableCellFrame& aCell,

                               nsCellMap*              aCellMap = nullptr) const;

  /** indicate whether the row has more than one cell that either originates

    * or is spanned from the rows above

    */

  bool HasMoreThanOneCell(int32_t aRowIndex) const;

  /** return the column frame associated with aColIndex

    * returns nullptr if the col frame has not yet been allocated, or if

    * aColIndex is out of range

    */

  nsTableColFrame* GetColFrame(int32_t aColIndex) const;

  /** Insert a col frame reference into the colframe cache and adapt the cellmap

    * @param aColFrame    - the column frame

    * @param aColIndex    - index where the column should be inserted into the

    *                       colframe cache

    */

  void InsertCol(nsTableColFrame& aColFrame,

                 int32_t          aColIndex);

  nsTableColGroupFrame* CreateSyntheticColGroupFrame();

  int32_t DestroyAnonymousColFrames(int32_t aNumFrames);

  // Append aNumColsToAdd anonymous col frames of type eColAnonymousCell to our

  // last synthetic colgroup.  If we have no such colgroup, then create one.

  void AppendAnonymousColFrames(int32_t aNumColsToAdd);

  // Append aNumColsToAdd anonymous col frames of type aColType to

  // aColGroupFrame.  If aAddToTable is true, also call AddColsToTable on the

  // new cols.

  void AppendAnonymousColFrames(nsTableColGroupFrame* aColGroupFrame,

                                int32_t               aNumColsToAdd,

                                nsTableColType        aColType,

                                bool                  aAddToTable);

  void MatchCellMapToColCache(nsTableCellMap* aCellMap);

  /** empty the column frame cache */

  void ClearColCache();

  void DidResizeColumns();

  void AppendCell(nsTableCellFrame& aCellFrame,

                  int32_t           aRowIndex);

  void InsertCells(nsTArray<nsTableCellFrame*>& aCellFrames,

                   int32_t                      aRowIndex,

                   int32_t                      aColIndexBefore);

  void RemoveCell(nsTableCellFrame* aCellFrame,

                  int32_t           aRowIndex);

  void AppendRows(nsTableRowGroupFrame*       aRowGroupFrame,

                  int32_t                     aRowIndex,

                  nsTArray<nsTableRowFrame*>& aRowFrames);

  int32_t InsertRows(nsTableRowGroupFrame*       aRowGroupFrame,

                     nsTArray<nsTableRowFrame*>& aFrames,

                     int32_t                     aRowIndex,

                     bool                        aConsiderSpans);

  void RemoveRows(nsTableRowFrame& aFirstRowFrame,

                  int32_t          aNumRowsToRemove,

                  bool             aConsiderSpans);

  /** Insert multiple rowgroups into the table cellmap handling

    * @param aRowGroups - iterator that iterates over the rowgroups to insert

    */

  void InsertRowGroups(const nsFrameList::Slice& aRowGroups);

  void InsertColGroups(int32_t                   aStartColIndex,

                       const nsFrameList::Slice& aColgroups);

  void RemoveCol(nsTableColGroupFrame* aColGroupFrame,

                 int32_t               aColIndex,

                 bool                  aRemoveFromCache,

                 bool                  aRemoveFromCellMap);

  bool ColumnHasCellSpacingBefore(int32_t aColIndex) const;

  bool HasPctCol() const;

  void SetHasPctCol(bool aValue);

  bool HasCellSpanningPctCol() const;

  void SetHasCellSpanningPctCol(bool aValue);

  /**

   * To be called on a frame by its parent after setting its size/position and

   * calling DidReflow (possibly via FinishReflowChild()).  This can also be

   * used for child frames which are not being reflowed but did have their size

   * or position changed.

   *

   * @param aFrame The frame to invalidate

   * @param aOrigRect The original rect of aFrame (before the change).

   * @param aOrigVisualOverflow The original overflow rect of aFrame.

   * @param aIsFirstReflow True if the size/position change is due to the

   *                       first reflow of aFrame.

   */

  static void InvalidateTableFrame(nsIFrame* aFrame,

                                   const nsRect& aOrigRect,

                                   const nsRect& aOrigVisualOverflow,

                                   bool aIsFirstReflow);

  virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override;

  // Return our wrapper frame.

  void AppendDirectlyOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) override;

protected:

  static void UpdateStyleOfOwnedAnonBoxesForTableWrapper(

    nsIFrame* aOwningFrame,

    nsIFrame* aWrapperFrame,

    mozilla::ServoRestyleState& aRestyleState);

  /** protected constructor.

    * @see NewFrame

    */

  explicit nsTableFrame(ComputedStyle* aStyle, ClassID aID = kClassID);

  /** destructor, responsible for mColumnLayoutData */

  virtual ~nsTableFrame();

  void InitChildReflowInput(ReflowInput& aReflowInput);

  virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowInput = nullptr) const override;

  void IterateBCBorders(BCPaintBorderAction& aAction, const nsRect& aDirtyRect);

public:

  bool IsRowInserted() const;

  void   SetRowInserted(bool aValue);

protected:

  // A helper function to reflow a header or footer with unconstrained height

  // to see if it should be made repeatable and also to determine its desired

  // height.

  nsresult SetupHeaderFooterChild(const TableReflowInput& aReflowInput,

                                  nsTableRowGroupFrame* aFrame,

                                  nscoord* aDesiredHeight);

  void ReflowChildren(TableReflowInput&  aReflowInput,

                      nsReflowStatus&      aStatus,

                      nsIFrame*&           aLastChildReflowed,

                      nsOverflowAreas&     aOverflowAreas);

  // This calls the col group and column reflow methods, which do two things:

  //  (1) set all the dimensions to 0

  //  (2) notify the table about colgroups or columns with hidden visibility

  void ReflowColGroups(gfxContext* aRenderingContext);

  /** return the isize of the table taking into account visibility collapse

    * on columns and colgroups

    * @param aBorderPadding  the border and padding of the table

    */

  nscoord GetCollapsedISize(const WritingMode aWM,

                            const LogicalMargin& aBorderPadding);

  /** Adjust the table for visibility.collapse set on rowgroups, rows,

    * colgroups and cols

    * @param aDesiredSize    the metrics of the table

    * @param aBorderPadding  the border and padding of the table

    */

  void AdjustForCollapsingRowsCols(ReflowOutput& aDesiredSize,

                                   const WritingMode aWM,

                                   const LogicalMargin& aBorderPadding);

  /** FixupPositionedTableParts is called at the end of table reflow to reflow

   *  the absolutely positioned descendants of positioned table parts. This is

   *  necessary because the dimensions of table parts may change after they've

   *  been reflowed (e.g. in AdjustForCollapsingRowsCols).

   */

  void FixupPositionedTableParts(nsPresContext*           aPresContext,

                                 ReflowOutput&     aDesiredSize,

                                 const ReflowInput& aReflowInput);

  // Clears the list of positioned table parts.

  void ClearAllPositionedTableParts();

  nsITableLayoutStrategy* LayoutStrategy() const {

    return static_cast<nsTableFrame*>(FirstInFlow())->

      mTableLayoutStrategy;

  }

  // Helper for InsertFrames.

  void HomogenousInsertFrames(ChildListID     aListID,

                              nsIFrame*       aPrevFrame,

                              nsFrameList&    aFrameList);

private:

  /* Handle a row that got inserted during reflow.  aNewHeight is the

     new height of the table after reflow. */

  void ProcessRowInserted(nscoord aNewHeight);

  // WIDTH AND HEIGHT CALCULATION

public:

  // calculate the computed block-size of aFrame including its border and

  // padding given its reflow state.

  nscoord CalcBorderBoxBSize(const ReflowInput& aReflowInput);

protected:

  // update the  desired block-size of this table taking into account the current

  // reflow state, the table attributes and the content driven rowgroup bsizes

  // this function can change the overflow area

  void CalcDesiredBSize(const ReflowInput& aReflowInput,

                        ReflowOutput& aDesiredSize);

  // The following is a helper for CalcDesiredBSize

  void DistributeBSizeToRows(const ReflowInput& aReflowInput,

                             nscoord                  aAmount);

  void PlaceChild(TableReflowInput&  aReflowInput,

                  nsIFrame*            aKidFrame,

                  nsPoint              aKidPosition,

                  ReflowOutput& aKidDesiredSize,

                  const nsRect&        aOriginalKidRect,

                  const nsRect&        aOriginalKidVisualOverflow);

   void PlaceRepeatedFooter(TableReflowInput& aReflowInput,

                            nsTableRowGroupFrame *aTfoot,

                            nscoord aFooterHeight);

  nsIFrame* GetFirstBodyRowGroupFrame();

public:

  typedef AutoTArray<nsTableRowGroupFrame*, 8> RowGroupArray;

  /**

   * Push all our child frames from the aRowGroups array, in order, starting

   * from the frame at aPushFrom to the end of the array. The frames are put on

   * our overflow list or moved directly to our next-in-flow if one exists.

   */

protected:

  void PushChildren(const RowGroupArray& aRowGroups, int32_t aPushFrom);

public:

  // put the children frames in the display order (e.g. thead before tbodies

  // before tfoot). This will handle calling GetRowGroupFrame() on the

  // children, and not append nulls, so the array is guaranteed to contain

  // nsTableRowGroupFrames.  If there are multiple theads or tfoots, all but

  // the first one are treated as tbodies instead.

  void OrderRowGroups(RowGroupArray& aChildren,

                      nsTableRowGroupFrame** aHead = nullptr,

                      nsTableRowGroupFrame** aFoot = nullptr) const;

  // Return the thead, if any

  nsTableRowGroupFrame* GetTHead() const;

  // Return the tfoot, if any

  nsTableRowGroupFrame* GetTFoot() const;

  // Returns true if there are any cells above the row at

  // aRowIndex and spanning into the row at aRowIndex, the number of

  // effective columns limits the search up to that column

  bool RowIsSpannedInto(int32_t aRowIndex, int32_t aNumEffCols);

  // Returns true if there is a cell originating in aRowIndex

  // which spans into the next row,  the number of effective

  // columns limits the search up to that column

  bool RowHasSpanningCells(int32_t aRowIndex, int32_t aNumEffCols);

protected:

  bool HaveReflowedColGroups() const;

  void   SetHaveReflowedColGroups(bool aValue);

public:

  bool IsBorderCollapse() const;

  bool NeedToCalcBCBorders() const;

  void SetNeedToCalcBCBorders(bool aValue);

  bool NeedToCollapse() const;

  void SetNeedToCollapse(bool aValue);

  bool NeedToCalcHasBCBorders() const;

  void SetNeedToCalcHasBCBorders(bool aValue);

  void CalcHasBCBorders();

  bool HasBCBorders();

  void SetHasBCBorders(bool aValue);

  /** The GeometryDirty bit is similar to the NS_FRAME_IS_DIRTY frame

    * state bit, which implies that all descendants are dirty.  The

    * GeometryDirty still implies that all the parts of the table are

    * dirty, but resizing optimizations should still apply to the

    * contents of the individual cells.

    */

  void SetGeometryDirty() { mBits.mGeometryDirty = true; }

  void ClearGeometryDirty() { mBits.mGeometryDirty = false; }

  bool IsGeometryDirty() const { return mBits.mGeometryDirty; }

  /** Get the cell map for this table frame.  It is not always mCellMap.

    * Only the firstInFlow has a legit cell map

    */

  nsTableCellMap* GetCellMap() const;

  /** Iterate over the row groups and adjust the row indices of all rows

   * whose index is >= aRowIndex.

   * @param aRowIndex   - start adjusting with this index

   * @param aAdjustment - shift the row index by this amount

   */

  void AdjustRowIndices(int32_t aRowIndex,

                        int32_t aAdjustment);

  /** Reset the rowindices of all rows as they might have changed due to

    * rowgroup reordering, exclude new row group frames that show in the

    * reordering but are not yet inserted into the cellmap

    * @param aRowGroupsToExclude - an iterator that will produce the row groups

    *                              to exclude.

    */

  void ResetRowIndices(const nsFrameList::Slice& aRowGroupsToExclude);

  nsTArray<nsTableColFrame*>& GetColCache();

protected:

  void SetBorderCollapse(bool aValue);

  BCPropertyData* GetBCProperty() const;

  BCPropertyData* GetOrCreateBCProperty();

  void SetFullBCDamageArea();

  void CalcBCBorders();

  void ExpandBCDamageArea(mozilla::TableArea& aRect) const;

  void SetColumnDimensions(nscoord aHeight, WritingMode aWM,

                           const LogicalMargin& aBorderPadding,

                           const nsSize& aContainerSize);

  int32_t CollectRows(nsIFrame*                   aFrame,

                      nsTArray<nsTableRowFrame*>& aCollection);

public: /* ----- Cell Map public methods ----- */

  int32_t GetStartRowIndex(nsTableRowGroupFrame* aRowGroupFrame);

  /** returns the number of rows in this table.

    */

  int32_t GetRowCount () const

  {

    return GetCellMap()->GetRowCount();

  }

  /** returns the number of columns in this table after redundant columns have been removed

    */

  int32_t GetEffectiveColCount() const;

  /* return the col count including dead cols */

  int32_t GetColCount () const

  {

    return GetCellMap()->GetColCount();

  }

  // return the last col index which isn't of type eColAnonymousCell

  int32_t GetIndexOfLastRealCol();

  /** returns true if table-layout:auto  */

  bool IsAutoLayout();

public:

  /* ---------- Row index management methods ------------ */

  /** Add the given index to the existing ranges of

   *  deleted row indices and merge ranges if, with the addition of the new

   *  index, they become consecutive.

   *  @param aDeletedRowStoredIndex - index of the row that was deleted

   *  Note - 'stored' index here refers to the index that was assigned to

   *  the row before any remove row operations were performed i.e. the

   *  value of mRowIndex and not the value returned by GetRowIndex()

   */

  void AddDeletedRowIndex(int32_t aDeletedRowStoredIndex);

  /** Calculate the change that aStoredIndex must be increased/decreased by

   *  to get new index.

   *  Note that aStoredIndex is always the index of an undeleted row (since

   *  rows that have already been deleted can never call this method).

   *  @param aStoredIndex - The stored index value that must be adjusted

   *  Note - 'stored' index here refers to the index that was assigned to

   *  the row before any remove row operations were performed i.e. the

   *  value of mRowIndex and not the value returned by GetRowIndex()

   */

  int32_t GetAdjustmentForStoredIndex(int32_t aStoredIndex);

  /** Returns whether mDeletedRowIndexRanges is empty

   */

  bool IsDeletedRowIndexRangesEmpty() const {

    return mDeletedRowIndexRanges.empty();

  }

public:

#ifdef DEBUG

  void Dump(bool            aDumpRows,

            bool            aDumpCols,

            bool            aDumpCellMap);

#endif

protected:

  /**

   * Helper method for RemoveFrame.

   */

  void DoRemoveFrame(ChildListID aListID, nsIFrame* aOldFrame);

#ifdef DEBUG

  void DumpRowGroup(nsIFrame* aChildFrame);

#endif

  // DATA MEMBERS

  AutoTArray<nsTableColFrame*, 8> mColFrames;

  struct TableBits {

    uint32_t mHaveReflowedColGroups:1; // have the col groups gotten their initial reflow

    uint32_t mHasPctCol:1;             // does any cell or col have a pct width

    uint32_t mCellSpansPctCol:1;       // does any cell span a col with a pct width (or containing a cell with a pct width)

    uint32_t mIsBorderCollapse:1;      // border collapsing model vs. separate model

    uint32_t mRowInserted:1;

    uint32_t mNeedToCalcBCBorders:1;

    uint32_t mGeometryDirty:1;

    uint32_t mIStartContBCBorder:8;

    uint32_t mNeedToCollapse:1;        // rows, cols that have visibility:collapse need to be collapsed

    uint32_t mResizedColumns:1;        // have we resized columns since last reflow?

    uint32_t mNeedToCalcHasBCBorders:1;

    uint32_t mHasBCBorders:1;

  } mBits;

  std::map<int32_t, int32_t> mDeletedRowIndexRanges; // maintains ranges of row

                                                     // indices of deleted rows

  nsTableCellMap*         mCellMap;            // maintains the relationships between rows, cols, and cells

  nsITableLayoutStrategy* mTableLayoutStrategy;// the layout strategy for this frame

  nsFrameList             mColGroups;          // the list of colgroup frames

};

inline bool nsTableFrame::IsRowGroup(mozilla::StyleDisplay aDisplayType) const

{

  return mozilla::StyleDisplay::TableHeaderGroup == aDisplayType ||

         mozilla::StyleDisplay::TableFooterGroup == aDisplayType ||

         mozilla::StyleDisplay::TableRowGroup    == aDisplayType;

}

inline void nsTableFrame::SetHaveReflowedColGroups(bool aValue)

{

  mBits.mHaveReflowedColGroups = aValue;

}

inline bool nsTableFrame::HaveReflowedColGroups() const

{

  return (bool)mBits.mHaveReflowedColGroups;

}

inline bool nsTableFrame::HasPctCol() const

{

  return (bool)mBits.mHasPctCol;

}

inline void nsTableFrame::SetHasPctCol(bool aValue)

{

  mBits.mHasPctCol = (unsigned)aValue;

}

inline bool nsTableFrame::HasCellSpanningPctCol() const

{

  return (bool)mBits.mCellSpansPctCol;

}

inline void nsTableFrame::SetHasCellSpanningPctCol(bool aValue)

{

  mBits.mCellSpansPctCol = (unsigned)aValue;

}

inline bool nsTableFrame::IsRowInserted() const

{

  return (bool)mBits.mRowInserted;

}

inline void nsTableFrame::SetRowInserted(bool aValue)

{

  mBits.mRowInserted = (unsigned)aValue;

}

inline void nsTableFrame::SetNeedToCollapse(bool aValue)

{

  static_cast<nsTableFrame*>(FirstInFlow())->mBits.mNeedToCollapse = (unsigned)aValue;

}

inline bool nsTableFrame::NeedToCollapse() const

{

  return (bool) static_cast<nsTableFrame*>(FirstInFlow())->mBits.mNeedToCollapse;

}

inline nsFrameList& nsTableFrame::GetColGroups()

{

  return static_cast<nsTableFrame*>(FirstInFlow())->mColGroups;

}

inline nsTArray<nsTableColFrame*>& nsTableFrame::GetColCache()

{

  return mColFrames;

}

inline bool nsTableFrame::IsBorderCollapse() const

{

  return (bool)mBits.mIsBorderCollapse;

}

inline void nsTableFrame::SetBorderCollapse(bool aValue)

{

  mBits.mIsBorderCollapse = aValue;

}

inline bool nsTableFrame::NeedToCalcBCBorders() const

{

  return (bool)mBits.mNeedToCalcBCBorders;

}

inline void nsTableFrame::SetNeedToCalcBCBorders(bool aValue)

{

  mBits.mNeedToCalcBCBorders = (unsigned)aValue;

}

inline bool nsTableFrame::NeedToCalcHasBCBorders() const

{

  return (bool)mBits.mNeedToCalcHasBCBorders;

}

inline void nsTableFrame::SetNeedToCalcHasBCBorders(bool aValue)

{

  mBits.mNeedToCalcHasBCBorders = (unsigned)aValue;

}

inline bool nsTableFrame::HasBCBorders()

{

  if (NeedToCalcHasBCBorders()) {

    CalcHasBCBorders();

    SetNeedToCalcHasBCBorders(false);

  }

  return (bool)mBits.mHasBCBorders;

}

inline void nsTableFrame::SetHasBCBorders(bool aValue)

{

  mBits.mHasBCBorders = (unsigned)aValue;

}

inline nscoord

nsTableFrame::GetContinuousIStartBCBorderWidth() const

{

  int32_t d2a = PresContext()->AppUnitsPerDevPixel();

  return BC_BORDER_END_HALF_COORD(d2a, mBits.mIStartContBCBorder);

}

inline void nsTableFrame::SetContinuousIStartBCBorderWidth(nscoord aValue)

{

  mBits.mIStartContBCBorder = (unsigned) aValue;

}

#define ABORT0() \

{NS_ASSERTION(false, "CellIterator program error"); \

return;}

#define ABORT1(aReturn) \

{NS_ASSERTION(false, "CellIterator program error"); \

return aReturn;}

#endif