зеркало из https://github.com/mozilla/gecko-dev.git
660 строки
25 KiB
C++
660 строки
25 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
// vim:cindent:ts=2:et:sw=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/. */
|
|
|
|
/* class that manages rules for positioning floats */
|
|
|
|
#ifndef nsFloatManager_h_
|
|
#define nsFloatManager_h_
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/WritingModes.h"
|
|
#include "nsCoord.h"
|
|
#include "nsFrameList.h" // for DEBUG_FRAME_DUMP
|
|
#include "nsIntervalSet.h"
|
|
#include "nsPoint.h"
|
|
#include "nsTArray.h"
|
|
|
|
class nsIPresShell;
|
|
class nsIFrame;
|
|
class nsPresContext;
|
|
namespace mozilla {
|
|
struct ReflowInput;
|
|
class StyleBasicShape;
|
|
} // namespace mozilla
|
|
|
|
/**
|
|
* The available space for content not occupied by floats is divided
|
|
* into a sequence of rectangles in the block direction. However, we
|
|
* need to know not only the rectangle, but also whether it was reduced
|
|
* (from the content rectangle) by floats that actually intruded into
|
|
* the content rectangle.
|
|
*/
|
|
struct nsFlowAreaRect {
|
|
mozilla::LogicalRect mRect;
|
|
bool mHasFloats;
|
|
|
|
nsFlowAreaRect(mozilla::WritingMode aWritingMode,
|
|
nscoord aICoord, nscoord aBCoord,
|
|
nscoord aISize, nscoord aBSize,
|
|
bool aHasFloats)
|
|
: mRect(aWritingMode, aICoord, aBCoord, aISize, aBSize)
|
|
, mHasFloats(aHasFloats) {}
|
|
};
|
|
|
|
#define NS_FLOAT_MANAGER_CACHE_SIZE 64
|
|
|
|
/**
|
|
* nsFloatManager is responsible for implementing CSS's rules for
|
|
* positioning floats. An nsFloatManager object is created during reflow for
|
|
* any block with NS_BLOCK_FLOAT_MGR. During reflow, the float manager for
|
|
* the nearest such ancestor block is found in ReflowInput::mFloatManager.
|
|
*
|
|
* According to the line-relative mappings in CSS Writing Modes spec [1],
|
|
* line-right and line-left are calculated with respect to the writing mode
|
|
* of the containing block of the floats. All the writing modes passed to
|
|
* nsFloatManager methods should be the containing block's writing mode.
|
|
*
|
|
* However, according to the abstract-to-physical mappings table [2], the
|
|
* 'direction' property of the containing block doesn't affect the
|
|
* interpretation of line-right and line-left. We actually implement this by
|
|
* passing in the writing mode of the block formatting context (BFC), i.e.
|
|
* the of BlockReflowInput's writing mode.
|
|
*
|
|
* nsFloatManager uses a special logical coordinate space with inline
|
|
* coordinates on the line-axis and block coordinates on the block-axis
|
|
* based on the writing mode of the block formatting context. All the
|
|
* physical types like nsRect, nsPoint, etc. use this coordinate space. See
|
|
* FloatInfo::mRect for an example.
|
|
*
|
|
* [1] https://drafts.csswg.org/css-writing-modes/#line-mappings
|
|
* [2] https://drafts.csswg.org/css-writing-modes/#logical-to-physical
|
|
*/
|
|
class nsFloatManager {
|
|
public:
|
|
explicit nsFloatManager(nsIPresShell* aPresShell, mozilla::WritingMode aWM);
|
|
~nsFloatManager();
|
|
|
|
void* operator new(size_t aSize) CPP_THROW_NEW;
|
|
void operator delete(void* aPtr, size_t aSize);
|
|
|
|
static void Shutdown();
|
|
|
|
/**
|
|
* Get float region stored on the frame. (Defaults to mRect if it's
|
|
* not there.) The float region is the area impacted by this float;
|
|
* the coordinates are relative to the containing block frame.
|
|
*/
|
|
static mozilla::LogicalRect GetRegionFor(mozilla::WritingMode aWM,
|
|
nsIFrame* aFloatFrame,
|
|
const nsSize& aContainerSize);
|
|
/**
|
|
* Calculate the float region for this frame using aMargin and the
|
|
* frame's mRect. The region includes the margins around the float,
|
|
* but doesn't include the relative offsets.
|
|
* Note that if the frame is or has a continuation, aMargin's top
|
|
* and/or bottom must be zeroed by the caller.
|
|
*/
|
|
static mozilla::LogicalRect CalculateRegionFor(
|
|
mozilla::WritingMode aWM,
|
|
nsIFrame* aFloatFrame,
|
|
const mozilla::LogicalMargin& aMargin,
|
|
const nsSize& aContainerSize);
|
|
/**
|
|
* Store the float region on the frame. The region is stored
|
|
* as a delta against the mRect, so repositioning the frame will
|
|
* also reposition the float region.
|
|
*/
|
|
static void StoreRegionFor(mozilla::WritingMode aWM,
|
|
nsIFrame* aFloat,
|
|
const mozilla::LogicalRect& aRegion,
|
|
const nsSize& aContainerSize);
|
|
|
|
// Structure that stores the current state of a float manager for
|
|
// Save/Restore purposes.
|
|
struct SavedState {
|
|
explicit SavedState() {}
|
|
private:
|
|
uint32_t mFloatInfoCount;
|
|
nscoord mLineLeft, mBlockStart;
|
|
bool mPushedLeftFloatPastBreak;
|
|
bool mPushedRightFloatPastBreak;
|
|
bool mSplitLeftFloatAcrossBreak;
|
|
bool mSplitRightFloatAcrossBreak;
|
|
|
|
friend class nsFloatManager;
|
|
};
|
|
|
|
/**
|
|
* Translate the current origin by the specified offsets. This
|
|
* creates a new local coordinate space relative to the current
|
|
* coordinate space.
|
|
*/
|
|
void Translate(nscoord aLineLeft, nscoord aBlockStart)
|
|
{
|
|
mLineLeft += aLineLeft;
|
|
mBlockStart += aBlockStart;
|
|
}
|
|
|
|
/**
|
|
* Returns the current translation from local coordinate space to
|
|
* world coordinate space. This represents the accumulated calls to
|
|
* Translate().
|
|
*/
|
|
void GetTranslation(nscoord& aLineLeft, nscoord& aBlockStart) const
|
|
{
|
|
aLineLeft = mLineLeft;
|
|
aBlockStart = mBlockStart;
|
|
}
|
|
|
|
/**
|
|
* Get information about the area available to content that flows
|
|
* around floats. Two different types of space can be requested:
|
|
* BandFromPoint: returns the band containing block-dir coordinate
|
|
* |aBCoord| (though actually with the top truncated to begin at
|
|
* aBCoord), but up to at most |aBSize| (which may be nscoord_MAX).
|
|
* This will return the tallest rectangle whose block start is
|
|
* |aBCoord| and in which there are no changes in what floats are
|
|
* on the sides of that rectangle, but will limit the block size
|
|
* of the rectangle to |aBSize|. The inline start and end edges
|
|
* of the rectangle give the area available for line boxes in that
|
|
* space. The inline size of this resulting rectangle will not be
|
|
* negative.
|
|
* WidthWithinHeight: This returns a rectangle whose block start
|
|
* is aBCoord and whose block size is exactly aBSize. Its inline
|
|
* start and end edges give the corresponding edges of the space
|
|
* that can be used for line boxes *throughout* that space. (It
|
|
* is possible that more inline space could be used in part of the
|
|
* space if a float begins or ends in it.) The inline size of the
|
|
* resulting rectangle can be negative.
|
|
*
|
|
* ShapeType can be used to request two different types of flow areas.
|
|
* (This is the float area defined in CSS Shapes Module Level 1 §1.4):
|
|
* Margin: uses the float element's margin-box to request the flow area.
|
|
* ShapeOutside: uses the float element's shape-outside value to request
|
|
* the float area.
|
|
*
|
|
* @param aBCoord [in] block-dir coordinate for block start of available space
|
|
* desired, which are positioned relative to the current translation.
|
|
* @param aBSize [in] see above
|
|
* @param aContentArea [in] an nsRect representing the content area
|
|
* @param aState [in] If null, use the current state, otherwise, do
|
|
* computation based only on floats present in the given
|
|
* saved state.
|
|
* @return An nsFlowAreaRect whose:
|
|
* mRect is the resulting rectangle for line boxes. It will not
|
|
* extend beyond aContentArea's inline bounds, but may be
|
|
* narrower when floats are present.
|
|
* mHasFloats is whether there are floats at the sides of the
|
|
* return value including those that do not reduce the line box
|
|
* inline size at all (because they are entirely in the margins)
|
|
*/
|
|
enum class BandInfoType { BandFromPoint, WidthWithinHeight };
|
|
enum class ShapeType { Margin, ShapeOutside };
|
|
nsFlowAreaRect GetFlowArea(mozilla::WritingMode aWM,
|
|
nscoord aBCoord, nscoord aBSize,
|
|
BandInfoType aBandInfoType, ShapeType aShapeType,
|
|
mozilla::LogicalRect aContentArea,
|
|
SavedState* aState,
|
|
const nsSize& aContainerSize) const;
|
|
|
|
/**
|
|
* Add a float that comes after all floats previously added. Its
|
|
* block start must be even with or below the top of all previous
|
|
* floats.
|
|
*
|
|
* aMarginRect is relative to the current translation. The caller
|
|
* must ensure aMarginRect.height >= 0 and aMarginRect.width >= 0.
|
|
*/
|
|
void AddFloat(nsIFrame* aFloatFrame,
|
|
const mozilla::LogicalRect& aMarginRect,
|
|
mozilla::WritingMode aWM, const nsSize& aContainerSize);
|
|
|
|
/**
|
|
* Notify that we tried to place a float that could not fit at all and
|
|
* had to be pushed to the next page/column? (If so, we can't place
|
|
* any more floats in this page/column because of the rule that the
|
|
* top of a float cannot be above the top of an earlier float. It
|
|
* also means that any clear needs to continue to the next column.)
|
|
*/
|
|
void SetPushedLeftFloatPastBreak()
|
|
{ mPushedLeftFloatPastBreak = true; }
|
|
void SetPushedRightFloatPastBreak()
|
|
{ mPushedRightFloatPastBreak = true; }
|
|
|
|
/**
|
|
* Notify that we split a float, with part of it needing to be pushed
|
|
* to the next page/column. (This means that any 'clear' needs to
|
|
* continue to the next page/column.)
|
|
*/
|
|
void SetSplitLeftFloatAcrossBreak()
|
|
{ mSplitLeftFloatAcrossBreak = true; }
|
|
void SetSplitRightFloatAcrossBreak()
|
|
{ mSplitRightFloatAcrossBreak = true; }
|
|
|
|
/**
|
|
* Remove the regions associated with this floating frame and its
|
|
* next-sibling list. Some of the frames may never have been added;
|
|
* we just skip those. This is not fully general; it only works as
|
|
* long as the N frames to be removed are the last N frames to have
|
|
* been added; if there's a frame in the middle of them that should
|
|
* not be removed, YOU LOSE.
|
|
*/
|
|
nsresult RemoveTrailingRegions(nsIFrame* aFrameList);
|
|
|
|
bool HasAnyFloats() const { return !mFloats.IsEmpty(); }
|
|
|
|
/**
|
|
* Methods for dealing with the propagation of float damage during
|
|
* reflow.
|
|
*/
|
|
bool HasFloatDamage() const
|
|
{
|
|
return !mFloatDamage.IsEmpty();
|
|
}
|
|
|
|
void IncludeInDamage(nscoord aIntervalBegin, nscoord aIntervalEnd)
|
|
{
|
|
mFloatDamage.IncludeInterval(aIntervalBegin + mBlockStart,
|
|
aIntervalEnd + mBlockStart);
|
|
}
|
|
|
|
bool IntersectsDamage(nscoord aIntervalBegin, nscoord aIntervalEnd) const
|
|
{
|
|
return mFloatDamage.Intersects(aIntervalBegin + mBlockStart,
|
|
aIntervalEnd + mBlockStart);
|
|
}
|
|
|
|
/**
|
|
* Saves the current state of the float manager into aState.
|
|
*/
|
|
void PushState(SavedState* aState);
|
|
|
|
/**
|
|
* Restores the float manager to the saved state.
|
|
*
|
|
* These states must be managed using stack discipline. PopState can only
|
|
* be used after PushState has been used to save the state, and it can only
|
|
* be used once --- although it can be omitted; saved states can be ignored.
|
|
* States must be popped in the reverse order they were pushed. A
|
|
* call to PopState invalidates any saved states Pushed after the
|
|
* state passed to PopState was pushed.
|
|
*/
|
|
void PopState(SavedState* aState);
|
|
|
|
/**
|
|
* Get the block start of the last float placed into the float
|
|
* manager, to enforce the rule that a float can't be above an earlier
|
|
* float. Returns the minimum nscoord value if there are no floats.
|
|
*
|
|
* The result is relative to the current translation.
|
|
*/
|
|
nscoord GetLowestFloatTop() const;
|
|
|
|
/**
|
|
* Return the coordinate of the lowest float matching aBreakType in
|
|
* this float manager. Returns aBCoord if there are no matching
|
|
* floats.
|
|
*
|
|
* Both aBCoord and the result are relative to the current translation.
|
|
*/
|
|
enum {
|
|
// Tell ClearFloats not to push to nscoord_MAX when floats have been
|
|
// pushed to the next page/column.
|
|
DONT_CLEAR_PUSHED_FLOATS = (1<<0)
|
|
};
|
|
nscoord ClearFloats(nscoord aBCoord, mozilla::StyleClear aBreakType,
|
|
uint32_t aFlags = 0) const;
|
|
|
|
/**
|
|
* Checks if clear would pass into the floats' BFC's next-in-flow,
|
|
* i.e. whether floats affecting this clear have continuations.
|
|
*/
|
|
bool ClearContinues(mozilla::StyleClear aBreakType) const;
|
|
|
|
void AssertStateMatches(SavedState *aState) const
|
|
{
|
|
NS_ASSERTION(aState->mLineLeft == mLineLeft &&
|
|
aState->mBlockStart == mBlockStart &&
|
|
aState->mPushedLeftFloatPastBreak ==
|
|
mPushedLeftFloatPastBreak &&
|
|
aState->mPushedRightFloatPastBreak ==
|
|
mPushedRightFloatPastBreak &&
|
|
aState->mSplitLeftFloatAcrossBreak ==
|
|
mSplitLeftFloatAcrossBreak &&
|
|
aState->mSplitRightFloatAcrossBreak ==
|
|
mSplitRightFloatAcrossBreak &&
|
|
aState->mFloatInfoCount == mFloats.Length(),
|
|
"float manager state should match saved state");
|
|
}
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
/**
|
|
* Dump the state of the float manager out to a file.
|
|
*/
|
|
nsresult List(FILE* out) const;
|
|
#endif
|
|
|
|
private:
|
|
|
|
// ShapeInfo is an abstract class for implementing all the shapes in CSS
|
|
// Shapes Module. A subclass needs to override all the methods to adjust
|
|
// the flow area with respect to its shape.
|
|
class ShapeInfo
|
|
{
|
|
public:
|
|
virtual ~ShapeInfo() {}
|
|
|
|
virtual nscoord LineLeft(const nscoord aBStart,
|
|
const nscoord aBEnd) const = 0;
|
|
virtual nscoord LineRight(const nscoord aBStart,
|
|
const nscoord aBEnd) const = 0;
|
|
virtual nscoord BStart() const = 0;
|
|
virtual nscoord BEnd() const = 0;
|
|
virtual bool IsEmpty() const = 0;
|
|
|
|
// Translate the current origin by the specified offsets.
|
|
virtual void Translate(nscoord aLineLeft, nscoord aBlockStart) = 0;
|
|
|
|
static mozilla::LogicalRect ComputeShapeBoxRect(
|
|
const mozilla::StyleShapeSource& aShapeOutside,
|
|
nsIFrame* const aFrame,
|
|
const mozilla::LogicalRect& aMarginRect,
|
|
mozilla::WritingMode aWM);
|
|
|
|
// Convert the LogicalRect to the special logical coordinate space used
|
|
// in float manager.
|
|
static nsRect ConvertToFloatLogical(const mozilla::LogicalRect& aRect,
|
|
mozilla::WritingMode aWM,
|
|
const nsSize& aContainerSize)
|
|
{
|
|
return nsRect(aRect.LineLeft(aWM, aContainerSize), aRect.BStart(aWM),
|
|
aRect.ISize(aWM), aRect.BSize(aWM));
|
|
}
|
|
|
|
static mozilla::UniquePtr<ShapeInfo> CreateShapeBox(
|
|
nsIFrame* const aFrame,
|
|
const mozilla::LogicalRect& aShapeBoxRect,
|
|
mozilla::WritingMode aWM,
|
|
const nsSize& aContainerSize);
|
|
|
|
static mozilla::UniquePtr<ShapeInfo> CreateInset(
|
|
const mozilla::StyleBasicShape* aBasicShape,
|
|
const mozilla::LogicalRect& aShapeBoxRect,
|
|
mozilla::WritingMode aWM,
|
|
const nsSize& aContainerSize);
|
|
|
|
static mozilla::UniquePtr<ShapeInfo> CreateCircleOrEllipse(
|
|
const mozilla::StyleBasicShape* aBasicShape,
|
|
const mozilla::LogicalRect& aShapeBoxRect,
|
|
mozilla::WritingMode aWM,
|
|
const nsSize& aContainerSize);
|
|
|
|
static mozilla::UniquePtr<ShapeInfo> CreatePolygon(
|
|
const mozilla::StyleBasicShape* aBasicShape,
|
|
const mozilla::LogicalRect& aShapeBoxRect,
|
|
mozilla::WritingMode aWM,
|
|
const nsSize& aContainerSize);
|
|
|
|
protected:
|
|
// Compute the minimum line-axis difference between the bounding shape
|
|
// box and its rounded corner within the given band (block-axis region).
|
|
// This is used as a helper function to compute the LineRight() and
|
|
// LineLeft(). See the picture in the implementation for an example.
|
|
// RadiusL and RadiusB stand for radius on the line-axis and block-axis.
|
|
//
|
|
// Returns radius-x diff on the line-axis, or 0 if there's no rounded
|
|
// corner within the given band.
|
|
static nscoord ComputeEllipseLineInterceptDiff(
|
|
const nscoord aShapeBoxBStart, const nscoord aShapeBoxBEnd,
|
|
const nscoord aBStartCornerRadiusL, const nscoord aBStartCornerRadiusB,
|
|
const nscoord aBEndCornerRadiusL, const nscoord aBEndCornerRadiusB,
|
|
const nscoord aBandBStart, const nscoord aBandBEnd);
|
|
|
|
static nscoord XInterceptAtY(const nscoord aY, const nscoord aRadiusX,
|
|
const nscoord aRadiusY);
|
|
|
|
// Convert the physical point to the special logical coordinate space
|
|
// used in float manager.
|
|
static nsPoint ConvertToFloatLogical(const nsPoint& aPoint,
|
|
mozilla::WritingMode aWM,
|
|
const nsSize& aContainerSize);
|
|
|
|
// Convert the half corner radii (nscoord[8]) to the special logical
|
|
// coordinate space used in float manager.
|
|
static mozilla::UniquePtr<nscoord[]> ConvertToFloatLogical(
|
|
const nscoord aRadii[8],
|
|
mozilla::WritingMode aWM);
|
|
};
|
|
|
|
// Implements shape-outside: <shape-box> and shape-outside: inset().
|
|
class RoundedBoxShapeInfo final : public ShapeInfo
|
|
{
|
|
public:
|
|
RoundedBoxShapeInfo(const nsRect& aRect,
|
|
mozilla::UniquePtr<nscoord[]> aRadii)
|
|
: mRect(aRect)
|
|
, mRadii(Move(aRadii))
|
|
{}
|
|
|
|
nscoord LineLeft(const nscoord aBStart,
|
|
const nscoord aBEnd) const override;
|
|
nscoord LineRight(const nscoord aBStart,
|
|
const nscoord aBEnd) const override;
|
|
nscoord BStart() const override { return mRect.y; }
|
|
nscoord BEnd() const override { return mRect.YMost(); }
|
|
bool IsEmpty() const override { return mRect.IsEmpty(); };
|
|
|
|
void Translate(nscoord aLineLeft, nscoord aBlockStart) override
|
|
{
|
|
mRect.MoveBy(aLineLeft, aBlockStart);
|
|
}
|
|
|
|
private:
|
|
// The rect of the rounded box shape in the float manager's coordinate
|
|
// space.
|
|
nsRect mRect;
|
|
// The half corner radii of the reference box. It's an nscoord[8] array
|
|
// in the float manager's coordinate space. If there are no radii, it's
|
|
// nullptr.
|
|
mozilla::UniquePtr<nscoord[]> mRadii;
|
|
};
|
|
|
|
// Implements shape-outside: circle() and shape-outside: ellipse().
|
|
class EllipseShapeInfo final : public ShapeInfo
|
|
{
|
|
public:
|
|
EllipseShapeInfo(const nsPoint& aCenter,
|
|
const nsSize& aRadii)
|
|
: mCenter(aCenter)
|
|
, mRadii(aRadii)
|
|
{}
|
|
|
|
nscoord LineLeft(const nscoord aBStart,
|
|
const nscoord aBEnd) const override;
|
|
nscoord LineRight(const nscoord aBStart,
|
|
const nscoord aBEnd) const override;
|
|
nscoord BStart() const override { return mCenter.y - mRadii.height; }
|
|
nscoord BEnd() const override { return mCenter.y + mRadii.height; }
|
|
bool IsEmpty() const override { return mRadii.IsEmpty(); };
|
|
|
|
void Translate(nscoord aLineLeft, nscoord aBlockStart) override
|
|
{
|
|
mCenter.MoveBy(aLineLeft, aBlockStart);
|
|
}
|
|
|
|
private:
|
|
// The position of the center of the ellipse. The coordinate space is the
|
|
// same as FloatInfo::mRect.
|
|
nsPoint mCenter;
|
|
// The radii of the ellipse in app units. The width and height represent
|
|
// the line-axis and block-axis radii of the ellipse.
|
|
nsSize mRadii;
|
|
};
|
|
|
|
// Implements shape-outside: polygon().
|
|
class PolygonShapeInfo final : public ShapeInfo
|
|
{
|
|
public:
|
|
explicit PolygonShapeInfo(nsTArray<nsPoint>&& aVertices);
|
|
|
|
nscoord LineLeft(const nscoord aBStart,
|
|
const nscoord aBEnd) const override;
|
|
nscoord LineRight(const nscoord aBStart,
|
|
const nscoord aBEnd) const override;
|
|
nscoord BStart() const override { return mBStart; }
|
|
nscoord BEnd() const override { return mBEnd; }
|
|
bool IsEmpty() const override { return mEmpty; }
|
|
|
|
void Translate(nscoord aLineLeft, nscoord aBlockStart) override;
|
|
|
|
private:
|
|
// Helper method for implementing LineLeft() and LineRight().
|
|
nscoord ComputeLineIntercept(
|
|
const nscoord aBStart,
|
|
const nscoord aBEnd,
|
|
nscoord (*aCompareOp) (std::initializer_list<nscoord>),
|
|
const nscoord aLineInterceptInitialValue) const;
|
|
|
|
// Given a horizontal line y, and two points p1 and p2 forming a line
|
|
// segment L. Solve x for the intersection of y and L. This method
|
|
// assumes y and L do intersect, and L is *not* horizontal.
|
|
static nscoord XInterceptAtY(const nscoord aY,
|
|
const nsPoint& aP1,
|
|
const nsPoint& aP2);
|
|
|
|
// The vertices of the polygon in the float manager's coordinate space.
|
|
nsTArray<nsPoint> mVertices;
|
|
|
|
// If mEmpty is true, that means the polygon encloses no area.
|
|
bool mEmpty = false;
|
|
|
|
// Computed block start and block end value of the polygon shape.
|
|
//
|
|
// If mEmpty is false, their initial values nscoord_MAX and nscoord_MIN
|
|
// are used as sentinels for computing min() and max() in the
|
|
// constructor, and mBStart is guaranteed to be less than or equal to
|
|
// mBEnd. If mEmpty is true, their values do not matter.
|
|
nscoord mBStart = nscoord_MAX;
|
|
nscoord mBEnd = nscoord_MIN;
|
|
};
|
|
|
|
struct FloatInfo {
|
|
nsIFrame *const mFrame;
|
|
// The lowest block-ends of left/right floats up to and including
|
|
// this one.
|
|
nscoord mLeftBEnd, mRightBEnd;
|
|
|
|
FloatInfo(nsIFrame* aFrame, nscoord aLineLeft, nscoord aBlockStart,
|
|
const mozilla::LogicalRect& aMarginRect,
|
|
mozilla::WritingMode aWM, const nsSize& aContainerSize);
|
|
|
|
nscoord LineLeft() const { return mRect.x; }
|
|
nscoord LineRight() const { return mRect.XMost(); }
|
|
nscoord ISize() const { return mRect.width; }
|
|
nscoord BStart() const { return mRect.y; }
|
|
nscoord BEnd() const { return mRect.YMost(); }
|
|
nscoord BSize() const { return mRect.height; }
|
|
bool IsEmpty() const { return mRect.IsEmpty(); }
|
|
|
|
// aBStart and aBEnd are the starting and ending coordinate of a band.
|
|
// LineLeft() and LineRight() return the innermost line-left extent and
|
|
// line-right extent within the given band, respectively.
|
|
nscoord LineLeft(ShapeType aShapeType,
|
|
const nscoord aBStart, const nscoord aBEnd) const;
|
|
nscoord LineRight(ShapeType aShapeType,
|
|
const nscoord aBStart, const nscoord aBEnd) const;
|
|
nscoord BStart(ShapeType aShapeType) const;
|
|
nscoord BEnd(ShapeType aShapeType) const;
|
|
bool IsEmpty(ShapeType aShapeType) const;
|
|
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
FloatInfo(FloatInfo&& aOther);
|
|
~FloatInfo();
|
|
#endif
|
|
|
|
// NB! This is really a logical rect in a writing mode suitable for
|
|
// placing floats, which is not necessarily the actual writing mode
|
|
// either of the block which created the float manager or the block
|
|
// that is calling the float manager. The inline coordinates are in
|
|
// the line-relative axis of the float manager and its block
|
|
// coordinates are in the float manager's block direction.
|
|
nsRect mRect;
|
|
// Pointer to a concrete subclass of ShapeInfo or null, which means that
|
|
// there is no shape-outside.
|
|
mozilla::UniquePtr<ShapeInfo> mShapeInfo;
|
|
};
|
|
|
|
#ifdef DEBUG
|
|
// Store the writing mode from the block frame which establishes the block
|
|
// formatting context (BFC) when the nsFloatManager is created.
|
|
mozilla::WritingMode mWritingMode;
|
|
#endif
|
|
|
|
// Translation from local to global coordinate space.
|
|
nscoord mLineLeft, mBlockStart;
|
|
// We use 11 here in order to fill up the jemalloc allocatoed chunk nicely,
|
|
// see https://bugzilla.mozilla.org/show_bug.cgi?id=1362876#c6.
|
|
AutoTArray<FloatInfo, 11> mFloats;
|
|
nsIntervalSet mFloatDamage;
|
|
|
|
// Did we try to place a float that could not fit at all and had to be
|
|
// pushed to the next page/column? If so, we can't place any more
|
|
// floats in this page/column because of the rule that the top of a
|
|
// float cannot be above the top of an earlier float. And we also
|
|
// need to apply this information to 'clear', and thus need to
|
|
// separate left and right floats.
|
|
bool mPushedLeftFloatPastBreak;
|
|
bool mPushedRightFloatPastBreak;
|
|
|
|
// Did we split a float, with part of it needing to be pushed to the
|
|
// next page/column. This means that any 'clear' needs to continue to
|
|
// the next page/column.
|
|
bool mSplitLeftFloatAcrossBreak;
|
|
bool mSplitRightFloatAcrossBreak;
|
|
|
|
static int32_t sCachedFloatManagerCount;
|
|
static void* sCachedFloatManagers[NS_FLOAT_MANAGER_CACHE_SIZE];
|
|
|
|
nsFloatManager(const nsFloatManager&) = delete;
|
|
void operator=(const nsFloatManager&) = delete;
|
|
};
|
|
|
|
/**
|
|
* A helper class to manage maintenance of the float manager during
|
|
* nsBlockFrame::Reflow. It automatically restores the old float
|
|
* manager in the reflow input when the object goes out of scope.
|
|
*/
|
|
class nsAutoFloatManager {
|
|
using ReflowInput = mozilla::ReflowInput;
|
|
|
|
public:
|
|
explicit nsAutoFloatManager(ReflowInput& aReflowInput)
|
|
: mReflowInput(aReflowInput)
|
|
, mOld(nullptr)
|
|
{}
|
|
|
|
~nsAutoFloatManager();
|
|
|
|
/**
|
|
* Create a new float manager for the specified frame. This will
|
|
* `remember' the old float manager, and install the new float
|
|
* manager in the reflow input.
|
|
*/
|
|
void
|
|
CreateFloatManager(nsPresContext *aPresContext);
|
|
|
|
protected:
|
|
ReflowInput &mReflowInput;
|
|
mozilla::UniquePtr<nsFloatManager> mNew;
|
|
|
|
// A non-owning pointer, which points to the object owned by
|
|
// nsAutoFloatManager::mNew.
|
|
nsFloatManager* mOld;
|
|
};
|
|
|
|
#endif /* !defined(nsFloatManager_h_) */
|