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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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/. */

/* struct containing the input to nsIFrame::Reflow */

#ifndef mozilla_ReflowInput_h

#define mozilla_ReflowInput_h

#include "nsMargin.h"

#include "nsStyleCoord.h"

#include "nsIFrame.h"

#include "mozilla/Assertions.h"

#include <algorithm>

class gfxContext;

class nsFloatManager;

struct nsHypotheticalPosition;

class nsIPercentBSizeObserver;

class nsLineLayout;

class nsPlaceholderFrame;

class nsPresContext;

/**

 * @return aValue clamped to [aMinValue, aMaxValue].

 *

 * @note This function needs to handle aMinValue > aMaxValue. In that case,

 *       aMinValue is returned.

 * @see http://www.w3.org/TR/CSS21/visudet.html#min-max-widths

 * @see http://www.w3.org/TR/CSS21/visudet.html#min-max-heights

 */

template <class NumericType>

NumericType

NS_CSS_MINMAX(NumericType aValue, NumericType aMinValue, NumericType aMaxValue)

{

  NumericType result = aValue;

  if (aMaxValue < result)

    result = aMaxValue;

  if (aMinValue > result)

    result = aMinValue;

  return result;

}

/**

 * CSS Frame type. Included as part of the reflow state.

 */

typedef uint32_t  nsCSSFrameType;

#define NS_CSS_FRAME_TYPE_UNKNOWN         0

#define NS_CSS_FRAME_TYPE_INLINE          1

#define NS_CSS_FRAME_TYPE_BLOCK           2  /* block-level in normal flow */

#define NS_CSS_FRAME_TYPE_FLOATING        3

#define NS_CSS_FRAME_TYPE_ABSOLUTE        4

#define NS_CSS_FRAME_TYPE_INTERNAL_TABLE  5  /* row group frame, row frame, cell frame, ... */

/**

 * Bit-flag that indicates whether the element is replaced. Applies to inline,

 * block-level, floating, and absolutely positioned elements

 */

#define NS_CSS_FRAME_TYPE_REPLACED                0x08000

/**

 * Bit-flag that indicates that the element is replaced and contains a block

 * (eg some form controls).  Applies to inline, block-level, floating, and

 * absolutely positioned elements.  Mutually exclusive with

 * NS_CSS_FRAME_TYPE_REPLACED.

 */

#define NS_CSS_FRAME_TYPE_REPLACED_CONTAINS_BLOCK 0x10000

/**

 * Helper macros for telling whether items are replaced

 */

#define NS_FRAME_IS_REPLACED_NOBLOCK(_ft) \

  (NS_CSS_FRAME_TYPE_REPLACED == ((_ft) & NS_CSS_FRAME_TYPE_REPLACED))

#define NS_FRAME_IS_REPLACED(_ft)            \

  (NS_FRAME_IS_REPLACED_NOBLOCK(_ft) ||      \

   NS_FRAME_IS_REPLACED_CONTAINS_BLOCK(_ft))

#define NS_FRAME_REPLACED(_ft) \

  (NS_CSS_FRAME_TYPE_REPLACED | (_ft))

#define NS_FRAME_IS_REPLACED_CONTAINS_BLOCK(_ft)         \

  (NS_CSS_FRAME_TYPE_REPLACED_CONTAINS_BLOCK ==         \

   ((_ft) & NS_CSS_FRAME_TYPE_REPLACED_CONTAINS_BLOCK))

#define NS_FRAME_REPLACED_CONTAINS_BLOCK(_ft) \

  (NS_CSS_FRAME_TYPE_REPLACED_CONTAINS_BLOCK | (_ft))

/**

 * A macro to extract the type. Masks off the 'replaced' bit-flag

 */

#define NS_FRAME_GET_TYPE(_ft)                           \

  ((_ft) & ~(NS_CSS_FRAME_TYPE_REPLACED |                \

             NS_CSS_FRAME_TYPE_REPLACED_CONTAINS_BLOCK))

namespace mozilla {

// A base class of ReflowInput that computes only the padding,

// border, and margin, since those values are needed more often.

struct SizeComputationInput {

public:

  typedef mozilla::WritingMode WritingMode;

  typedef mozilla::LogicalMargin LogicalMargin;

  // The frame being reflowed.

  nsIFrame* mFrame;

  // Rendering context to use for measurement.

  gfxContext* mRenderingContext;

  const nsMargin& ComputedPhysicalMargin() const { return mComputedMargin; }

  const nsMargin& ComputedPhysicalBorderPadding() const { return mComputedBorderPadding; }

  const nsMargin& ComputedPhysicalPadding() const { return mComputedPadding; }

  // We may need to eliminate the (few) users of these writable-reference accessors

  // as part of migrating to logical coordinates.

  nsMargin& ComputedPhysicalMargin() { return mComputedMargin; }

  nsMargin& ComputedPhysicalBorderPadding() { return mComputedBorderPadding; }

  nsMargin& ComputedPhysicalPadding() { return mComputedPadding; }

  const LogicalMargin ComputedLogicalMargin() const

    { return LogicalMargin(mWritingMode, mComputedMargin); }

  const LogicalMargin ComputedLogicalBorderPadding() const

    { return LogicalMargin(mWritingMode, mComputedBorderPadding); }

  const LogicalMargin ComputedLogicalPadding() const

    { return LogicalMargin(mWritingMode, mComputedPadding); }

  void SetComputedLogicalMargin(mozilla::WritingMode aWM,

                                const LogicalMargin& aMargin)

    { mComputedMargin = aMargin.GetPhysicalMargin(aWM); }

  void SetComputedLogicalMargin(const LogicalMargin& aMargin)

    { SetComputedLogicalMargin(mWritingMode, aMargin); }

  void SetComputedLogicalBorderPadding(mozilla::WritingMode aWM,

                                       const LogicalMargin& aMargin)

    { mComputedBorderPadding = aMargin.GetPhysicalMargin(aWM); }

  void SetComputedLogicalBorderPadding(const LogicalMargin& aMargin)

    { SetComputedLogicalBorderPadding(mWritingMode, aMargin); }

  void SetComputedLogicalPadding(mozilla::WritingMode aWM,

                                 const LogicalMargin& aMargin)

    { mComputedPadding = aMargin.GetPhysicalMargin(aWM); }

  void SetComputedLogicalPadding(const LogicalMargin& aMargin)

    { SetComputedLogicalPadding(mWritingMode, aMargin); }

  WritingMode GetWritingMode() const { return mWritingMode; }

protected:

  // cached copy of the frame's writing-mode, for logical coordinates

  WritingMode      mWritingMode;

  // These are PHYSICAL coordinates (for now).

  // Will probably become logical in due course.

  // Computed margin values

  nsMargin         mComputedMargin;

  // Cached copy of the border + padding values

  nsMargin         mComputedBorderPadding;

  // Computed padding values

  nsMargin         mComputedPadding;

public:

  // Callers using this constructor must call InitOffsets on their own.

  SizeComputationInput(nsIFrame *aFrame, gfxContext *aRenderingContext)

    : mFrame(aFrame)

    , mRenderingContext(aRenderingContext)

    , mWritingMode(aFrame->GetWritingMode())

  {

  }

  SizeComputationInput(nsIFrame *aFrame, gfxContext *aRenderingContext,

                   mozilla::WritingMode aContainingBlockWritingMode,

                   nscoord aContainingBlockISize);

  struct ReflowInputFlags {

    ReflowInputFlags() { memset(this, 0, sizeof(*this)); }

    bool mSpecialBSizeReflow : 1;    // used by tables to communicate special reflow (in process) to handle

                                     // percent bsize frames inside cells which may not have computed bsizes

    bool mNextInFlowUntouched : 1;   // nothing in the frame's next-in-flow (or its descendants)

                                     // is changing

    bool mIsTopOfPage : 1;           // Is the current context at the top of a

                                     // page?  When true, we force something

                                     // that's too tall for a page/column to

                                     // fit anyway to avoid infinite loops.

    bool mAssumingHScrollbar : 1;    // parent frame is an nsIScrollableFrame and it

                                     // is assuming a horizontal scrollbar

    bool mAssumingVScrollbar : 1;    // parent frame is an nsIScrollableFrame and it

                                     // is assuming a vertical scrollbar

    bool mIsIResize : 1;             // Is frame (a) not dirty and (b) a

                                     // different inline-size than before?

    bool mIsBResize : 1;             // Is frame (a) not dirty and (b) a

                                     // different block-size than before or

                                     // (potentially) in a context where

                                     // percent block-sizes have a different

                                     // basis?

    bool mTableIsSplittable : 1;     // tables are splittable, this should happen only inside a page

                                     // and never insider a column frame

    bool mHeightDependsOnAncestorCell : 1;     // Does frame height depend on

                                               // an ancestor table-cell?

    bool mIsColumnBalancing : 1;     // nsColumnSetFrame is balancing columns

    bool mIsFlexContainerMeasuringBSize : 1;   // nsFlexContainerFrame is

                                               // reflowing this child to

                                               // measure its intrinsic BSize.

    bool mDummyParentReflowInput : 1;   // a "fake" reflow state made

                                        // in order to be the parent

                                        // of a real one

    bool mMustReflowPlaceholders : 1;   // Should this frame reflow its place-

                                        // holder children? If the available

                                        // height of this frame didn't change,

                                        // but its in a paginated environment

                                        // (e.g. columns), it should always

                                        // reflow its placeholder children.

    bool mShrinkWrap : 1; // stores the COMPUTE_SIZE_SHRINK_WRAP ctor flag

    bool mUseAutoBSize : 1; // stores the COMPUTE_SIZE_USE_AUTO_BSIZE ctor flag

    bool mStaticPosIsCBOrigin : 1; // the STATIC_POS_IS_CB_ORIGIN ctor flag

    bool mIClampMarginBoxMinSize : 1; // the I_CLAMP_MARGIN_BOX_MIN_SIZE ctor flag

    bool mBClampMarginBoxMinSize : 1; // the B_CLAMP_MARGIN_BOX_MIN_SIZE ctor flag

    bool mApplyAutoMinSize : 1;       // the I_APPLY_AUTO_MIN_SIZE ctor flag

    // If set, the following two flags indicate that:

    // (1) this frame is absolutely-positioned (or fixed-positioned).

    // (2) this frame's static position depends on the CSS Box Alignment.

    // (3) we do need to compute the static position, because the frame's

    //     {Inline and/or Block} offsets actually depend on it.

    // When these bits are set, the offset values (IStart/IEnd, BStart/BEnd)

    // represent the "start" edge of the frame's CSS Box Alignment container

    // area, in that axis -- and these offsets need to be further-resolved

    // (with CSS Box Alignment) after we know the OOF frame's size.

    // NOTE: The "I" and "B" (for "Inline" and "Block") refer the axes of the

    // *containing block's writing-mode*, NOT mFrame's own writing-mode. This

    // is purely for convenience, since that's the writing-mode we're dealing

    // with when we set & react to these bits.

    bool mIOffsetsNeedCSSAlign : 1;

    bool mBOffsetsNeedCSSAlign : 1;

  };

#ifdef DEBUG

  // Reflow trace methods.  Defined in nsFrame.cpp so they have access

  // to the display-reflow infrastructure.

  static void* DisplayInitOffsetsEnter(

                                     nsIFrame* aFrame,

                                     SizeComputationInput* aState,

                                     nscoord aPercentBasis,

                                     WritingMode aCBWritingMode,

                                     const nsMargin* aBorder,

                                     const nsMargin* aPadding);

  static void DisplayInitOffsetsExit(nsIFrame* aFrame,

                                     SizeComputationInput* aState,

                                     void* aValue);

#endif

private:

  /**

   * Computes margin values from the specified margin style information, and

   * fills in the mComputedMargin member.

   *

   * @param aWM Writing mode of the containing block

   * @param aPercentBasis

   *    Inline size of the containing block (in its own writing mode), to use

   *    for resolving percentage margin values in the inline and block axes.

   * @return true if the margin is dependent on the containing block size.

   */

  bool ComputeMargin(mozilla::WritingMode aWM,

                     nscoord aPercentBasis);

  /**

   * Computes padding values from the specified padding style information, and

   * fills in the mComputedPadding member.

   *

   * @param aWM Writing mode of the containing block

   * @param aPercentBasis

   *    Inline size of the containing block (in its own writing mode), to use

   *    for resolving percentage padding values in the inline and block axes.

   * @return true if the padding is dependent on the containing block size.

   */

  bool ComputePadding(mozilla::WritingMode aWM,

                      nscoord aPercentBasis,

                      mozilla::LayoutFrameType aFrameType);

protected:

  void InitOffsets(mozilla::WritingMode aWM,

                   nscoord aPercentBasis,

                   mozilla::LayoutFrameType aFrameType,

                   ReflowInputFlags aFlags,

                   const nsMargin* aBorder = nullptr,

                   const nsMargin* aPadding = nullptr,

                   const nsStyleDisplay* aDisplay = nullptr);

  /*

   * Convert nsStyleCoord to nscoord when percentages depend on the

   * inline size of the containing block, and enumerated values are for

   * inline size, min-inline-size, or max-inline-size.  Does not handle

   * auto inline sizes.

   */

  inline nscoord ComputeISizeValue(nscoord aContainingBlockISize,

                                   nscoord aContentEdgeToBoxSizing,

                                   nscoord aBoxSizingToMarginEdge,

                                   const nsStyleCoord& aCoord) const;

  // same as previous, but using mComputedBorderPadding, mComputedPadding,

  // and mComputedMargin

  nscoord ComputeISizeValue(nscoord aContainingBlockISize,

                            mozilla::StyleBoxSizing aBoxSizing,

                            const nsStyleCoord& aCoord) const;

  nscoord ComputeBSizeValue(nscoord aContainingBlockBSize,

                            mozilla::StyleBoxSizing aBoxSizing,

                            const nsStyleCoord& aCoord) const;

};

/**

 * State passed to a frame during reflow or intrinsic size calculation.

 *

 * XXX Refactor so only a base class (nsSizingState?) is used for intrinsic

 * size calculation.

 *

 * @see nsIFrame#Reflow()

 */

struct ReflowInput : public SizeComputationInput {

  // the reflow states are linked together. this is the pointer to the

  // parent's reflow state

  const ReflowInput* mParentReflowInput;

  // A non-owning pointer to the float manager associated with this area,

  // which points to the object owned by nsAutoFloatManager::mNew.

  nsFloatManager* mFloatManager;

  // LineLayout object (only for inline reflow; set to nullptr otherwise)

  nsLineLayout*    mLineLayout;

  // The appropriate reflow state for the containing block (for

  // percentage widths, etc.) of this reflow state's frame.

  const ReflowInput* mCBReflowInput;

  // The type of frame, from css's perspective. This value is

  // initialized by the Init method below.

  MOZ_INIT_OUTSIDE_CTOR

  nsCSSFrameType   mFrameType;

  // The amount the in-flow position of the block is moving vertically relative

  // to its previous in-flow position (i.e. the amount the line containing the

  // block is moving).

  // This should be zero for anything which is not a block outside, and it

  // should be zero for anything which has a non-block parent.

  // The intended use of this value is to allow the accurate determination

  // of the potential impact of a float

  // This takes on an arbitrary value the first time a block is reflowed

  nscoord mBlockDelta;

  // If an ReflowInput finds itself initialized with an unconstrained

  // inline-size, it will look up its parentReflowInput chain for a state

  // with an orthogonal writing mode and a non-NS_UNCONSTRAINEDSIZE value for

  // orthogonal limit; when it finds such a reflow-state, it will use its

  // orthogonal-limit value to constrain inline-size.

  // This is initialized to NS_UNCONSTRAINEDSIZE (so it will be ignored),

  // but reset to a suitable value for the reflow root by nsPresShell.

  nscoord mOrthogonalLimit;

  // Accessors for the private fields below. Forcing all callers to use these

  // will allow us to introduce logical-coordinate versions and gradually

  // change clients from physical to logical as needed; and potentially switch

  // the internal fields from physical to logical coordinates in due course,

  // while maintaining compatibility with not-yet-updated code.

  nscoord AvailableWidth() const { return mAvailableWidth; }

  nscoord AvailableHeight() const { return mAvailableHeight; }

  nscoord ComputedWidth() const { return mComputedWidth; }

  nscoord ComputedHeight() const { return mComputedHeight; }

  nscoord ComputedMinWidth() const { return mComputedMinWidth; }

  nscoord ComputedMaxWidth() const { return mComputedMaxWidth; }

  nscoord ComputedMinHeight() const { return mComputedMinHeight; }

  nscoord ComputedMaxHeight() const { return mComputedMaxHeight; }

  nscoord& AvailableWidth() { return mAvailableWidth; }

  nscoord& AvailableHeight() { return mAvailableHeight; }

  nscoord& ComputedWidth() { return mComputedWidth; }

  nscoord& ComputedHeight() { return mComputedHeight; }

  nscoord& ComputedMinWidth() { return mComputedMinWidth; }

  nscoord& ComputedMaxWidth() { return mComputedMaxWidth; }

  nscoord& ComputedMinHeight() { return mComputedMinHeight; }

  nscoord& ComputedMaxHeight() { return mComputedMaxHeight; }

  // ISize and BSize are logical-coordinate dimensions:

  // ISize is the size in the writing mode's inline direction (which equates to

  // width in horizontal writing modes, height in vertical ones), and BSize is

  // the size in the block-progression direction.

  nscoord AvailableISize() const

    { return mWritingMode.IsVertical() ? mAvailableHeight : mAvailableWidth; }

  nscoord AvailableBSize() const

    { return mWritingMode.IsVertical() ? mAvailableWidth : mAvailableHeight; }

  nscoord ComputedISize() const

    { return mWritingMode.IsVertical() ? mComputedHeight : mComputedWidth; }

  nscoord ComputedBSize() const

    { return mWritingMode.IsVertical() ? mComputedWidth : mComputedHeight; }

  nscoord ComputedMinISize() const

    { return mWritingMode.IsVertical() ? mComputedMinHeight : mComputedMinWidth; }

  nscoord ComputedMaxISize() const

    { return mWritingMode.IsVertical() ? mComputedMaxHeight : mComputedMaxWidth; }

  nscoord ComputedMinBSize() const

    { return mWritingMode.IsVertical() ? mComputedMinWidth : mComputedMinHeight; }

  nscoord ComputedMaxBSize() const

    { return mWritingMode.IsVertical() ? mComputedMaxWidth : mComputedMaxHeight; }

  nscoord& AvailableISize()

    { return mWritingMode.IsVertical() ? mAvailableHeight : mAvailableWidth; }

  nscoord& AvailableBSize()

    { return mWritingMode.IsVertical() ? mAvailableWidth : mAvailableHeight; }

  nscoord& ComputedISize()

    { return mWritingMode.IsVertical() ? mComputedHeight : mComputedWidth; }

  nscoord& ComputedBSize()

    { return mWritingMode.IsVertical() ? mComputedWidth : mComputedHeight; }

  nscoord& ComputedMinISize()

    { return mWritingMode.IsVertical() ? mComputedMinHeight : mComputedMinWidth; }

  nscoord& ComputedMaxISize()

    { return mWritingMode.IsVertical() ? mComputedMaxHeight : mComputedMaxWidth; }

  nscoord& ComputedMinBSize()

    { return mWritingMode.IsVertical() ? mComputedMinWidth : mComputedMinHeight; }

  nscoord& ComputedMaxBSize()

    { return mWritingMode.IsVertical() ? mComputedMaxWidth : mComputedMaxHeight; }

  mozilla::LogicalSize AvailableSize() const {

    return mozilla::LogicalSize(mWritingMode,

                                AvailableISize(), AvailableBSize());

  }

  mozilla::LogicalSize ComputedSize() const {

    return mozilla::LogicalSize(mWritingMode,

                                ComputedISize(), ComputedBSize());

  }

  mozilla::LogicalSize ComputedMinSize() const {

    return mozilla::LogicalSize(mWritingMode,

                                ComputedMinISize(), ComputedMinBSize());

  }

  mozilla::LogicalSize ComputedMaxSize() const {

    return mozilla::LogicalSize(mWritingMode,

                                ComputedMaxISize(), ComputedMaxBSize());

  }

  mozilla::LogicalSize AvailableSize(mozilla::WritingMode aWM) const

  { return AvailableSize().ConvertTo(aWM, mWritingMode); }

  mozilla::LogicalSize ComputedSize(mozilla::WritingMode aWM) const

    { return ComputedSize().ConvertTo(aWM, mWritingMode); }

  mozilla::LogicalSize ComputedMinSize(mozilla::WritingMode aWM) const

    { return ComputedMinSize().ConvertTo(aWM, mWritingMode); }

  mozilla::LogicalSize ComputedMaxSize(mozilla::WritingMode aWM) const

    { return ComputedMaxSize().ConvertTo(aWM, mWritingMode); }

  mozilla::LogicalSize ComputedSizeWithPadding() const {

    mozilla::WritingMode wm = GetWritingMode();

    return mozilla::LogicalSize(wm,

                                ComputedISize() +

                                ComputedLogicalPadding().IStartEnd(wm),

                                ComputedBSize() +

                                ComputedLogicalPadding().BStartEnd(wm));

  }

  mozilla::LogicalSize ComputedSizeWithPadding(mozilla::WritingMode aWM) const {

    return ComputedSizeWithPadding().ConvertTo(aWM, GetWritingMode());

  }

  mozilla::LogicalSize ComputedSizeWithBorderPadding() const {

    mozilla::WritingMode wm = GetWritingMode();

    return mozilla::LogicalSize(wm,

                                ComputedISize() +

                                ComputedLogicalBorderPadding().IStartEnd(wm),

                                ComputedBSize() +

                                ComputedLogicalBorderPadding().BStartEnd(wm));

  }

  mozilla::LogicalSize

  ComputedSizeWithBorderPadding(mozilla::WritingMode aWM) const {

    return ComputedSizeWithBorderPadding().ConvertTo(aWM, GetWritingMode());

  }

  mozilla::LogicalSize

  ComputedSizeWithMarginBorderPadding() const {

    mozilla::WritingMode wm = GetWritingMode();

    return mozilla::LogicalSize(wm,

                                ComputedISize() +

                                ComputedLogicalMargin().IStartEnd(wm) +

                                ComputedLogicalBorderPadding().IStartEnd(wm),

                                ComputedBSize() +

                                ComputedLogicalMargin().BStartEnd(wm) +

                                ComputedLogicalBorderPadding().BStartEnd(wm));

  }

  mozilla::LogicalSize

  ComputedSizeWithMarginBorderPadding(mozilla::WritingMode aWM) const {

    return ComputedSizeWithMarginBorderPadding().ConvertTo(aWM,

                                                           GetWritingMode());

  }

  nsSize

  ComputedPhysicalSize() const {

    return nsSize(ComputedWidth(), ComputedHeight());

  }

  // XXX this will need to change when we make mComputedOffsets logical;

  // we won't be able to return a reference for the physical offsets

  const nsMargin& ComputedPhysicalOffsets() const { return mComputedOffsets; }

  nsMargin& ComputedPhysicalOffsets() { return mComputedOffsets; }

  const LogicalMargin ComputedLogicalOffsets() const

    { return LogicalMargin(mWritingMode, mComputedOffsets); }

  void SetComputedLogicalOffsets(const LogicalMargin& aOffsets)

    { mComputedOffsets = aOffsets.GetPhysicalMargin(mWritingMode); }

  // Return the state's computed size including border-padding, with

  // unconstrained dimensions replaced by zero.

  nsSize ComputedSizeAsContainerIfConstrained() const {

    const nscoord wd = ComputedWidth();

    const nscoord ht = ComputedHeight();

    return nsSize(wd == NS_UNCONSTRAINEDSIZE

                  ? 0 : wd + ComputedPhysicalBorderPadding().LeftRight(),

                  ht == NS_UNCONSTRAINEDSIZE

                  ? 0 : ht + ComputedPhysicalBorderPadding().TopBottom());

  }

private:

  // the available width in which to reflow the frame. The space

  // represents the amount of room for the frame's margin, border,

  // padding, and content area. The frame size you choose should fit

  // within the available width.

  nscoord              mAvailableWidth;

  // A value of NS_UNCONSTRAINEDSIZE for the available height means

  // you can choose whatever size you want. In galley mode the

  // available height is always NS_UNCONSTRAINEDSIZE, and only page

  // mode or multi-column layout involves a constrained height. The

  // element's the top border and padding, and content, must fit. If the

  // element is complete after reflow then its bottom border, padding

  // and margin (and similar for its complete ancestors) will need to

  // fit in this height.

  nscoord              mAvailableHeight;

  // The computed width specifies the frame's content area width, and it does

  // not apply to inline non-replaced elements

  //

  // For replaced inline frames, a value of NS_INTRINSICSIZE means you should

  // use your intrinsic width as the computed width

  //

  // For block-level frames, the computed width is based on the width of the

  // containing block, the margin/border/padding areas, and the min/max width.

  MOZ_INIT_OUTSIDE_CTOR

  nscoord          mComputedWidth;

  // The computed height specifies the frame's content height, and it does

  // not apply to inline non-replaced elements

  //

  // For replaced inline frames, a value of NS_INTRINSICSIZE means you should

  // use your intrinsic height as the computed height

  //

  // For non-replaced block-level frames in the flow and floated, a value of

  // NS_AUTOHEIGHT means you choose a height to shrink wrap around the normal

  // flow child frames. The height must be within the limit of the min/max

  // height if there is such a limit

  //

  // For replaced block-level frames, a value of NS_INTRINSICSIZE

  // means you use your intrinsic height as the computed height

  MOZ_INIT_OUTSIDE_CTOR

  nscoord          mComputedHeight;

  // Computed values for 'left/top/right/bottom' offsets. Only applies to

  // 'positioned' elements. These are PHYSICAL coordinates (for now).

  nsMargin         mComputedOffsets;

  // Computed values for 'min-width/max-width' and 'min-height/max-height'

  // XXXldb The width ones here should go; they should be needed only

  // internally.

  MOZ_INIT_OUTSIDE_CTOR

  nscoord          mComputedMinWidth, mComputedMaxWidth;

  MOZ_INIT_OUTSIDE_CTOR

  nscoord          mComputedMinHeight, mComputedMaxHeight;

public:

  // Our saved containing block dimensions.

  MOZ_INIT_OUTSIDE_CTOR

  LogicalSize      mContainingBlockSize;

  // Cached pointers to the various style structs used during intialization

  MOZ_INIT_OUTSIDE_CTOR

  const nsStyleDisplay*    mStyleDisplay;

  MOZ_INIT_OUTSIDE_CTOR

  const nsStyleVisibility* mStyleVisibility;

  MOZ_INIT_OUTSIDE_CTOR

  const nsStylePosition*   mStylePosition;

  MOZ_INIT_OUTSIDE_CTOR

  const nsStyleBorder*     mStyleBorder;

  MOZ_INIT_OUTSIDE_CTOR

  const nsStyleMargin*     mStyleMargin;

  MOZ_INIT_OUTSIDE_CTOR

  const nsStylePadding*    mStylePadding;

  MOZ_INIT_OUTSIDE_CTOR

  const nsStyleText*       mStyleText;

  bool IsFloating() const;

  mozilla::StyleDisplay GetDisplay() const;

  // a frame (e.g. nsTableCellFrame) which may need to generate a special

  // reflow for percent bsize calculations

  nsIPercentBSizeObserver* mPercentBSizeObserver;

  // CSS margin collapsing sometimes requires us to reflow

  // optimistically assuming that margins collapse to see if clearance

  // is required. When we discover that clearance is required, we

  // store the frame in which clearance was discovered to the location

  // requested here.

  nsIFrame** mDiscoveredClearance;

  ReflowInputFlags mFlags;

  // This value keeps track of how deeply nested a given reflow state

  // is from the top of the frame tree.

  int16_t mReflowDepth;

  // Logical and physical accessors for the resize flags. All users should go

  // via these accessors, so that in due course we can change the storage from

  // physical to logical.

  bool IsHResize() const {

    return mWritingMode.IsVertical() ? mFlags.mIsBResize : mFlags.mIsIResize;

  }

  bool IsVResize() const {

    return mWritingMode.IsVertical() ? mFlags.mIsIResize : mFlags.mIsBResize;

  }

  bool IsIResize() const {

    return mFlags.mIsIResize;

  }

  bool IsBResize() const {

    return mFlags.mIsBResize;

  }

  bool IsBResizeForWM(mozilla::WritingMode aWM) const {

    return aWM.IsOrthogonalTo(mWritingMode) ? mFlags.mIsIResize

                                            : mFlags.mIsBResize;

  }

  void SetHResize(bool aValue) {

    if (mWritingMode.IsVertical()) {

      mFlags.mIsBResize = aValue;

    } else {

      mFlags.mIsIResize = aValue;

    }

  }

  void SetVResize(bool aValue) {

    if (mWritingMode.IsVertical()) {

      mFlags.mIsIResize = aValue;

    } else {

      mFlags.mIsBResize = aValue;

    }

  }

  void SetIResize(bool aValue) {

    mFlags.mIsIResize = aValue;

  }

  void SetBResize(bool aValue) {

    mFlags.mIsBResize = aValue;

  }

  // Note: The copy constructor is written by the compiler automatically. You

  // can use that and then override specific values if you want, or you can

  // call Init as desired...

  /**

   * Initialize a ROOT reflow state.

   *

   * @param aPresContext Must be equal to aFrame->PresContext().

   * @param aFrame The frame for whose reflow state is being constructed.

   * @param aRenderingContext The rendering context to be used for measurements.

   * @param aAvailableSpace See comments for availableHeight and availableWidth

   *        members.

   * @param aFlags A set of flags used for additional boolean parameters (see

   *        below).

   */

  ReflowInput(nsPresContext*              aPresContext,

              nsIFrame*                   aFrame,

              gfxContext*                 aRenderingContext,

              const mozilla::LogicalSize& aAvailableSpace,

              uint32_t                    aFlags = 0);

  /**

   * Initialize a reflow state for a child frame's reflow. Some parts of the

   * state are copied from the parent's reflow state. The remainder is computed.

   *

   * @param aPresContext Must be equal to aFrame->PresContext().

   * @param aParentReflowInput A reference to an ReflowInput object that

   *        is to be the parent of this object.

   * @param aFrame The frame for whose reflow state is being constructed.

   * @param aAvailableSpace See comments for availableHeight and availableWidth

   *        members.

   * @param aContainingBlockSize An optional size, in app units, specifying

   *        the containing block size to use instead of the default which is

   *        to use the aAvailableSpace.

   * @param aFlags A set of flags used for additional boolean parameters (see

   *        below).

   */

  ReflowInput(nsPresContext*              aPresContext,

              const ReflowInput&    aParentReflowInput,

              nsIFrame*                   aFrame,

              const mozilla::LogicalSize& aAvailableSpace,

              const mozilla::LogicalSize* aContainingBlockSize = nullptr,

              uint32_t                    aFlags = 0);

  // Values for |aFlags| passed to constructor

  enum {

    // Indicates that the parent of this reflow state is "fake" (see

    // mDummyParentReflowInput in mFlags).

    DUMMY_PARENT_REFLOW_STATE = (1<<0),

    // Indicates that the calling function will initialize the reflow state, and

    // that the constructor should not call Init().

    CALLER_WILL_INIT = (1<<1),

    // The caller wants shrink-wrap behavior (i.e. ComputeSizeFlags::eShrinkWrap

    // will be passed to ComputeSize()).

    COMPUTE_SIZE_SHRINK_WRAP = (1<<2),

    // The caller wants 'auto' bsize behavior (ComputeSizeFlags::eUseAutoBSize

    // will be be passed to ComputeSize()).

    COMPUTE_SIZE_USE_AUTO_BSIZE = (1<<3),

    // The caller wants the abs.pos. static-position resolved at the origin of

    // the containing block, i.e. at LogicalPoint(0, 0). (Note that this

    // doesn't necessarily mean that (0, 0) is the *correct* static position

    // for the frame in question.)

    STATIC_POS_IS_CB_ORIGIN = (1<<4),

    // Pass ComputeSizeFlags::eIClampMarginBoxMinSize to ComputeSize().

    I_CLAMP_MARGIN_BOX_MIN_SIZE = (1<<5),

    // Pass ComputeSizeFlags::eBClampMarginBoxMinSize to ComputeSize().

    B_CLAMP_MARGIN_BOX_MIN_SIZE = (1<<6),

    // Pass ComputeSizeFlags::eIApplyAutoMinSize to ComputeSize().

    I_APPLY_AUTO_MIN_SIZE = (1<<7),

  };

  // This method initializes various data members. It is automatically

  // called by the various constructors

  void Init(nsPresContext*              aPresContext,

            const mozilla::LogicalSize* aContainingBlockSize = nullptr,

            const nsMargin*             aBorder = nullptr,

            const nsMargin*             aPadding = nullptr);

  /**

   * Find the content isize of our containing block for the given writing mode,

   * which need not be the same as the reflow state's mode.

   */

  nscoord GetContainingBlockContentISize(mozilla::WritingMode aWritingMode) const;

  /**

   * Calculate the used line-height property. The return value will be >= 0.

   */

  nscoord CalcLineHeight() const;

  /**

   * Same as CalcLineHeight() above, but doesn't need a reflow state.

   *

   * @param aBlockBSize The computed block size of the content rect of the block

   *                     that the line should fill.

   *                     Only used with line-height:-moz-block-height.

   *                     NS_AUTOHEIGHT results in a normal line-height for

   *                     line-height:-moz-block-height.

   * @param aFontSizeInflation The result of the appropriate

   *                           nsLayoutUtils::FontSizeInflationFor call,

   *                           or 1.0 if during intrinsic size

   *                           calculation.

   */

  static nscoord CalcLineHeight(nsIContent* aContent,

                                ComputedStyle* aComputedStyle,

                                nsPresContext* aPresContext,

                                nscoord aBlockBSize,

                                float aFontSizeInflation);

  mozilla::LogicalSize ComputeContainingBlockRectangle(

         nsPresContext*           aPresContext,

         const ReflowInput* aContainingBlockRI) const;

  /**

   * Apply the mComputed(Min/Max)Width constraints to the content

   * size computed so far.

   */

  nscoord ApplyMinMaxWidth(nscoord aWidth) const {

    if (NS_UNCONSTRAINEDSIZE != ComputedMaxWidth()) {

      aWidth = std::min(aWidth, ComputedMaxWidth());

    }

    return std::max(aWidth, ComputedMinWidth());

  }

  /**

   * Apply the mComputed(Min/Max)ISize constraints to the content

   * size computed so far.

   */

  nscoord ApplyMinMaxISize(nscoord aISize) const {

    if (NS_UNCONSTRAINEDSIZE != ComputedMaxISize()) {

      aISize = std::min(aISize, ComputedMaxISize());

    }

    return std::max(aISize, ComputedMinISize());

  }

  /**

   * Apply the mComputed(Min/Max)Height constraints to the content

   * size computed so far.

   *

   * @param aHeight The height that we've computed an to which we want to apply

   *        min/max constraints.

   * @param aConsumed The amount of the computed height that was consumed by

   *        our prev-in-flows.

   */

  nscoord ApplyMinMaxHeight(nscoord aHeight, nscoord aConsumed = 0) const {

    aHeight += aConsumed;

    if (NS_UNCONSTRAINEDSIZE != ComputedMaxHeight()) {

      aHeight = std::min(aHeight, ComputedMaxHeight());

    }

    if (NS_UNCONSTRAINEDSIZE != ComputedMinHeight()) {

      aHeight = std::max(aHeight, ComputedMinHeight());

    }

    return aHeight - aConsumed;

  }

  /**

   * Apply the mComputed(Min/Max)BSize constraints to the content

   * size computed so far.

   *

   * @param aBSize The block-size that we've computed an to which we want to apply

   *        min/max constraints.

   * @param aConsumed The amount of the computed block-size that was consumed by

   *        our prev-in-flows.

   */

  nscoord ApplyMinMaxBSize(nscoord aBSize, nscoord aConsumed = 0) const {

    aBSize += aConsumed;

    if (NS_UNCONSTRAINEDSIZE != ComputedMaxBSize()) {

      aBSize = std::min(aBSize, ComputedMaxBSize());

    }

    if (NS_UNCONSTRAINEDSIZE != ComputedMinBSize()) {

      aBSize = std::max(aBSize, ComputedMinBSize());

    }

    return aBSize - aConsumed;

  }

  bool ShouldReflowAllKids() const {

    // Note that we could make a stronger optimization for IsBResize if

    // we use it in a ShouldReflowChild test that replaces the current

    // checks of NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN, if it

    // were tested there along with NS_FRAME_CONTAINS_RELATIVE_BSIZE.

    // This would need to be combined with a slight change in which

    // frames NS_FRAME_CONTAINS_RELATIVE_BSIZE is marked on.

    return (mFrame->GetStateBits() & NS_FRAME_IS_DIRTY) ||

           IsIResize() ||

           (IsBResize() &&

            (mFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE));

  }

  // This method doesn't apply min/max computed widths to the value passed in.

  void SetComputedWidth(nscoord aComputedWidth);

  // This method doesn't apply min/max computed heights to the value passed in.

  void SetComputedHeight(nscoord aComputedHeight);

  void SetComputedISize(nscoord aComputedISize) {

    if (mWritingMode.IsVertical()) {

      SetComputedHeight(aComputedISize);

    } else {

      SetComputedWidth(aComputedISize);

    }

  }

  void SetComputedBSize(nscoord aComputedBSize) {

    if (mWritingMode.IsVertical()) {

      SetComputedWidth(aComputedBSize);

    } else {

      SetComputedHeight(aComputedBSize);

    }

  }

  void SetComputedBSizeWithoutResettingResizeFlags(nscoord aComputedBSize) {

    // Viewport frames reset the computed block size on a copy of their reflow

    // state when reflowing fixed-pos kids.  In that case we actually don't

    // want to mess with the resize flags, because comparing the frame's rect

    // to the munged computed isize is pointless.

    ComputedBSize() = aComputedBSize;

  }

  void SetTruncated(const ReflowOutput& aMetrics, nsReflowStatus* aStatus) const;

  bool WillReflowAgainForClearance() const {

    return mDiscoveredClearance && *mDiscoveredClearance;

  }

  // Compute the offsets for a relative position element

  static void ComputeRelativeOffsets(mozilla::WritingMode aWM,

                                     nsIFrame* aFrame,

                                     const mozilla::LogicalSize& aCBSize,

                                     nsMargin& aComputedOffsets);

  // If a relatively positioned element, adjust the position appropriately.

  static void ApplyRelativePositioning(nsIFrame* aFrame,

                                       const nsMargin& aComputedOffsets,

                                       nsPoint* aPosition);

  void ApplyRelativePositioning(nsPoint* aPosition) const {

    ApplyRelativePositioning(mFrame, ComputedPhysicalOffsets(), aPosition);

  }

  static void

  ApplyRelativePositioning(nsIFrame* aFrame,

                           mozilla::WritingMode aWritingMode,

                           const mozilla::LogicalMargin& aComputedOffsets,

                           mozilla::LogicalPoint* aPosition,

                           const nsSize& aContainerSize) {

    // Subtract the size of the frame from the container size that we

    // use for converting between the logical and physical origins of

    // the frame. This accounts for the fact that logical origins in RTL

    // coordinate systems are at the top right of the frame instead of

    // the top left.

    nsSize frameSize = aFrame->GetSize();

    nsPoint pos = aPosition->GetPhysicalPoint(aWritingMode,

                                              aContainerSize - frameSize);

    ApplyRelativePositioning(aFrame,

                             aComputedOffsets.GetPhysicalMargin(aWritingMode),

                             &pos);

    *aPosition = mozilla::LogicalPoint(aWritingMode, pos,

                                       aContainerSize - frameSize);

  }

  void ApplyRelativePositioning(mozilla::LogicalPoint* aPosition,

                                const nsSize& aContainerSize) const {

    ApplyRelativePositioning(mFrame, mWritingMode,

                             ComputedLogicalOffsets(), aPosition,

                             aContainerSize);

  }

#ifdef DEBUG

  // Reflow trace methods.  Defined in nsFrame.cpp so they have access

  // to the display-reflow infrastructure.

  static void* DisplayInitConstraintsEnter(nsIFrame* aFrame,

                                           ReflowInput* aState,

                                           nscoord aCBISize,

                                           nscoord aCBBSize,

                                           const nsMargin* aBorder,

                                           const nsMargin* aPadding);

  static void DisplayInitConstraintsExit(nsIFrame* aFrame,

                                         ReflowInput* aState,

                                         void* aValue);

  static void* DisplayInitFrameTypeEnter(nsIFrame* aFrame,

                                         ReflowInput* aState);

  static void DisplayInitFrameTypeExit(nsIFrame* aFrame,

                                       ReflowInput* aState,

                                       void* aValue);

#endif

protected:

  void InitFrameType(LayoutFrameType aFrameType);

  void InitCBReflowInput();

  void InitResizeFlags(nsPresContext* aPresContext,

                       mozilla::LayoutFrameType aFrameType);

  void InitConstraints(nsPresContext* aPresContext,

                       const mozilla::LogicalSize& aContainingBlockSize,

                       const nsMargin* aBorder,

                       const nsMargin* aPadding,

                       mozilla::LayoutFrameType aFrameType);

  // Returns the nearest containing block or block frame (whether or not

  // it is a containing block) for the specified frame.  Also returns

  // the inline-start edge and logical size of the containing block's

  // content area.

  // These are returned in the coordinate space of the containing block.

  nsIFrame* GetHypotheticalBoxContainer(nsIFrame* aFrame,

                                        nscoord& aCBIStartEdge,

                                        mozilla::LogicalSize& aCBSize) const;

  // Calculate a "hypothetical box" position where the placeholder frame

  // (for a position:fixed/absolute element) would have been placed if it were

  // positioned statically. The hypothetical box position will have a writing

  // mode with the same block direction as the absolute containing block

  // (aReflowInput->frame), though it may differ in inline direction.

  void CalculateHypotheticalPosition(nsPresContext* aPresContext,

                                     nsPlaceholderFrame* aPlaceholderFrame,

                                     const ReflowInput* aReflowInput,

                                     nsHypotheticalPosition& aHypotheticalPos,

                                     mozilla::LayoutFrameType aFrameType) const;

  void InitAbsoluteConstraints(nsPresContext* aPresContext,

                               const ReflowInput* aReflowInput,

                               const mozilla::LogicalSize& aContainingBlockSize,

                               mozilla::LayoutFrameType aFrameType);

  // Calculates the computed values for the 'min-Width', 'max-Width',

  // 'min-Height', and 'max-Height' properties, and stores them in the assorted

  // data members

  void ComputeMinMaxValues(const mozilla::LogicalSize& aContainingBlockSize);

  // aInsideBoxSizing returns the part of the padding, border, and margin

  // in the aAxis dimension that goes inside the edge given by box-sizing;

  // aOutsideBoxSizing returns the rest.

  void CalculateBorderPaddingMargin(mozilla::LogicalAxis aAxis,

                                    nscoord aContainingBlockSize,

                                    nscoord* aInsideBoxSizing,

                                    nscoord* aOutsideBoxSizing) const;

  void CalculateBlockSideMargins(LayoutFrameType aFrameType);

};

} // namespace mozilla

#endif // mozilla_ReflowInput_h