mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
288 lines
10 KiB
C++
288 lines
10 KiB
C++
/* -*- 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/. */
|
|
|
|
/* state used in reflow of block frames */
|
|
|
|
#ifndef nsBlockReflowState_h__
|
|
#define nsBlockReflowState_h__
|
|
|
|
#include "nsFloatManager.h"
|
|
#include "nsLineBox.h"
|
|
#include "nsHTMLReflowState.h"
|
|
|
|
class nsBlockFrame;
|
|
class nsFrameList;
|
|
class nsOverflowContinuationTracker;
|
|
|
|
// block reflow state flags
|
|
#define BRS_UNCONSTRAINEDHEIGHT 0x00000001
|
|
#define BRS_ISTOPMARGINROOT 0x00000002 // Is this frame a root for top/bottom margin collapsing?
|
|
#define BRS_ISBOTTOMMARGINROOT 0x00000004
|
|
#define BRS_APPLYTOPMARGIN 0x00000008 // See ShouldApplyTopMargin
|
|
#define BRS_ISFIRSTINFLOW 0x00000010
|
|
// Set when mLineAdjacentToTop is valid
|
|
#define BRS_HAVELINEADJACENTTOTOP 0x00000020
|
|
// Set when the block has the equivalent of NS_BLOCK_FLOAT_MGR
|
|
#define BRS_FLOAT_MGR 0x00000040
|
|
// Set when nsLineLayout::LineIsEmpty was true at the end of reflowing
|
|
// the current line
|
|
#define BRS_LINE_LAYOUT_EMPTY 0x00000080
|
|
#define BRS_ISOVERFLOWCONTAINER 0x00000100
|
|
// Our mPushedFloats list is stored on the blocks' proptable
|
|
#define BRS_PROPTABLE_FLOATCLIST 0x00000200
|
|
#define BRS_LASTFLAG BRS_PROPTABLE_FLOATCLIST
|
|
|
|
class nsBlockReflowState {
|
|
public:
|
|
nsBlockReflowState(const nsHTMLReflowState& aReflowState,
|
|
nsPresContext* aPresContext,
|
|
nsBlockFrame* aFrame,
|
|
bool aTopMarginRoot, bool aBottomMarginRoot,
|
|
bool aBlockNeedsFloatManager,
|
|
nscoord aConsumedHeight = NS_INTRINSICSIZE);
|
|
|
|
/**
|
|
* Get the available reflow space (the area not occupied by floats)
|
|
* for the current y coordinate. The available space is relative to
|
|
* our coordinate system, which is the content box, with (0, 0) in the
|
|
* upper left.
|
|
*
|
|
* Returns whether there are floats present at the given vertical
|
|
* coordinate and within the width of the content rect.
|
|
*/
|
|
nsFlowAreaRect GetFloatAvailableSpace() const
|
|
{ return GetFloatAvailableSpace(mY); }
|
|
nsFlowAreaRect GetFloatAvailableSpace(nscoord aY) const
|
|
{ return GetFloatAvailableSpaceWithState(aY, nullptr); }
|
|
nsFlowAreaRect
|
|
GetFloatAvailableSpaceWithState(nscoord aY,
|
|
nsFloatManager::SavedState *aState) const;
|
|
nsFlowAreaRect
|
|
GetFloatAvailableSpaceForHeight(nscoord aY, nscoord aHeight,
|
|
nsFloatManager::SavedState *aState) const;
|
|
|
|
/*
|
|
* The following functions all return true if they were able to
|
|
* place the float, false if the float did not fit in available
|
|
* space.
|
|
* aLineLayout is null when we are reflowing pushed floats (because
|
|
* they are not associated with a line box).
|
|
*/
|
|
bool AddFloat(nsLineLayout* aLineLayout,
|
|
nsIFrame* aFloat,
|
|
nscoord aAvailableWidth);
|
|
private:
|
|
bool CanPlaceFloat(nscoord aFloatWidth,
|
|
const nsFlowAreaRect& aFloatAvailableSpace);
|
|
public:
|
|
bool FlowAndPlaceFloat(nsIFrame* aFloat);
|
|
private:
|
|
void PushFloatPastBreak(nsIFrame* aFloat);
|
|
public:
|
|
void PlaceBelowCurrentLineFloats(nsFloatCacheFreeList& aFloats,
|
|
nsLineBox* aLine);
|
|
|
|
// Returns the first coordinate >= aY that clears the
|
|
// floats indicated by aBreakType and has enough width between floats
|
|
// (or no floats remaining) to accomodate aReplacedBlock.
|
|
nscoord ClearFloats(nscoord aY, uint8_t aBreakType,
|
|
nsIFrame *aReplacedBlock = nullptr,
|
|
uint32_t aFlags = 0);
|
|
|
|
bool IsAdjacentWithTop() const {
|
|
return mY ==
|
|
((mFlags & BRS_ISFIRSTINFLOW) ? mReflowState.ComputedPhysicalBorderPadding().top : 0);
|
|
}
|
|
|
|
/**
|
|
* Adjusts the border/padding to return 0 for the top if
|
|
* we are not the first in flow.
|
|
*/
|
|
nsMargin BorderPadding() const {
|
|
nsMargin result = mReflowState.ComputedPhysicalBorderPadding();
|
|
if (!(mFlags & BRS_ISFIRSTINFLOW)) {
|
|
result.top = 0;
|
|
if (mFlags & BRS_ISOVERFLOWCONTAINER) {
|
|
result.bottom = 0;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the height "consumed" by any previous-in-flows.
|
|
*/
|
|
nscoord GetConsumedHeight();
|
|
|
|
// Reconstruct the previous bottom margin that goes above |aLine|.
|
|
void ReconstructMarginAbove(nsLineList::iterator aLine);
|
|
|
|
// Caller must have called GetAvailableSpace for the correct position
|
|
// (which need not be the current mY).
|
|
void ComputeReplacedBlockOffsetsForFloats(nsIFrame* aFrame,
|
|
const nsRect& aFloatAvailableSpace,
|
|
nscoord& aLeftResult,
|
|
nscoord& aRightResult);
|
|
|
|
// Caller must have called GetAvailableSpace for the current mY
|
|
void ComputeBlockAvailSpace(nsIFrame* aFrame,
|
|
const nsStyleDisplay* aDisplay,
|
|
const nsFlowAreaRect& aFloatAvailableSpace,
|
|
bool aBlockAvoidsFloats,
|
|
nsRect& aResult);
|
|
|
|
protected:
|
|
void RecoverFloats(nsLineList::iterator aLine, nscoord aDeltaY);
|
|
|
|
public:
|
|
void RecoverStateFrom(nsLineList::iterator aLine, nscoord aDeltaY);
|
|
|
|
void AdvanceToNextLine() {
|
|
if (GetFlag(BRS_LINE_LAYOUT_EMPTY)) {
|
|
SetFlag(BRS_LINE_LAYOUT_EMPTY, false);
|
|
} else {
|
|
mLineNumber++;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------
|
|
|
|
// This state is the "global" state computed once for the reflow of
|
|
// the block.
|
|
|
|
// The block frame that is using this object
|
|
nsBlockFrame* mBlock;
|
|
|
|
nsPresContext* mPresContext;
|
|
|
|
const nsHTMLReflowState& mReflowState;
|
|
|
|
nsFloatManager* mFloatManager;
|
|
|
|
// The coordinates within the float manager where the block is being
|
|
// placed <b>after</b> taking into account the blocks border and
|
|
// padding. This, therefore, represents the inner "content area" (in
|
|
// spacemanager coordinates) where child frames will be placed,
|
|
// including child blocks and floats.
|
|
nscoord mFloatManagerX, mFloatManagerY;
|
|
|
|
// XXX get rid of this
|
|
nsReflowStatus mReflowStatus;
|
|
|
|
// The float manager state as it was before the contents of this
|
|
// block. This is needed for positioning bullets, since we only want
|
|
// to move the bullet to flow around floats that were before this
|
|
// block, not floats inside of it.
|
|
nsFloatManager::SavedState mFloatManagerStateBefore;
|
|
|
|
nscoord mBottomEdge;
|
|
|
|
// The content area to reflow child frames within. This is within
|
|
// this frame's coordinate system, which means mContentArea.x ==
|
|
// BorderPadding().left and mContentArea.y == BorderPadding().top.
|
|
// The height may be NS_UNCONSTRAINEDSIZE, which indicates that there
|
|
// is no page/column boundary below (the common case).
|
|
// mContentArea.YMost() should only be called after checking that
|
|
// mContentArea.height is not NS_UNCONSTRAINEDSIZE; otherwise
|
|
// coordinate overflow may occur.
|
|
nsRect mContentArea;
|
|
|
|
// Continuation out-of-flow float frames that need to move to our
|
|
// next in flow are placed here during reflow. It's a pointer to
|
|
// a frame list stored in the block's property table.
|
|
nsFrameList *mPushedFloats;
|
|
// This method makes sure pushed floats are accessible to
|
|
// StealFrame. Call it before adding any frames to mPushedFloats.
|
|
void SetupPushedFloatList();
|
|
// Use this method to append to mPushedFloats.
|
|
void AppendPushedFloat(nsIFrame* aFloatCont);
|
|
|
|
// Track child overflow continuations.
|
|
nsOverflowContinuationTracker* mOverflowTracker;
|
|
|
|
//----------------------------------------
|
|
|
|
// This state is "running" state updated by the reflow of each line
|
|
// in the block. This same state is "recovered" when a line is not
|
|
// dirty and is passed over during incremental reflow.
|
|
|
|
// The current line being reflowed
|
|
// If it is mBlock->end_lines(), then it is invalid.
|
|
nsLineList::iterator mCurrentLine;
|
|
|
|
// When BRS_HAVELINEADJACENTTOTOP is set, this refers to a line
|
|
// which we know is adjacent to the top of the block (in other words,
|
|
// all lines before it are empty and do not have clearance. This line is
|
|
// always before the current line.
|
|
nsLineList::iterator mLineAdjacentToTop;
|
|
|
|
// The current Y coordinate in the block
|
|
nscoord mY;
|
|
|
|
// The overflow areas of all floats placed so far
|
|
nsOverflowAreas mFloatOverflowAreas;
|
|
|
|
nsFloatCacheFreeList mFloatCacheFreeList;
|
|
|
|
// Previous child. This is used when pulling up a frame to update
|
|
// the sibling list.
|
|
nsIFrame* mPrevChild;
|
|
|
|
// The previous child frames collapsed bottom margin value.
|
|
nsCollapsingMargin mPrevBottomMargin;
|
|
|
|
// The current next-in-flow for the block. When lines are pulled
|
|
// from a next-in-flow, this is used to know which next-in-flow to
|
|
// pull from. When a next-in-flow is emptied of lines, we advance
|
|
// this to the next next-in-flow.
|
|
nsBlockFrame* mNextInFlow;
|
|
|
|
//----------------------------------------
|
|
|
|
// Temporary line-reflow state. This state is used during the reflow
|
|
// of a given line, but doesn't have meaning before or after.
|
|
|
|
// The list of floats that are "current-line" floats. These are
|
|
// added to the line after the line has been reflowed, to keep the
|
|
// list fiddling from being N^2.
|
|
nsFloatCacheFreeList mCurrentLineFloats;
|
|
|
|
// The list of floats which are "below current-line"
|
|
// floats. These are reflowed/placed after the line is reflowed
|
|
// and placed. Again, this is done to keep the list fiddling from
|
|
// being N^2.
|
|
nsFloatCacheFreeList mBelowCurrentLineFloats;
|
|
|
|
nscoord mMinLineHeight;
|
|
|
|
int32_t mLineNumber;
|
|
|
|
int16_t mFlags;
|
|
|
|
uint8_t mFloatBreakType;
|
|
|
|
// The amount of computed height "consumed" by previous-in-flows.
|
|
nscoord mConsumedHeight;
|
|
|
|
void SetFlag(uint32_t aFlag, bool aValue)
|
|
{
|
|
NS_ASSERTION(aFlag<=BRS_LASTFLAG, "bad flag");
|
|
if (aValue) { // set flag
|
|
mFlags |= aFlag;
|
|
}
|
|
else { // unset flag
|
|
mFlags &= ~aFlag;
|
|
}
|
|
}
|
|
|
|
bool GetFlag(uint32_t aFlag) const
|
|
{
|
|
NS_ASSERTION(aFlag<=BRS_LASTFLAG, "bad flag");
|
|
return !!(mFlags & aFlag);
|
|
}
|
|
};
|
|
|
|
#endif // nsBlockReflowState_h__
|