mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
349 lines
12 KiB
C++
349 lines
12 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 "nsIntervalSet.h"
|
|
#include "nsCoord.h"
|
|
#include "nsRect.h"
|
|
#include "nsTArray.h"
|
|
|
|
class nsIPresShell;
|
|
class nsIFrame;
|
|
struct nsHTMLReflowState;
|
|
class nsPresContext;
|
|
|
|
/**
|
|
* The available space for content not occupied by floats is divided
|
|
* into a (vertical) sequence of rectangles. 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 {
|
|
nsRect mRect;
|
|
bool mHasFloats;
|
|
|
|
nsFlowAreaRect(nscoord aX, nscoord aY, nscoord aWidth, nscoord aHeight,
|
|
bool aHasFloats)
|
|
: mRect(aX, aY, aWidth, aHeight), mHasFloats(aHasFloats) {}
|
|
};
|
|
|
|
#define NS_FLOAT_MANAGER_CACHE_SIZE 4
|
|
|
|
class nsFloatManager {
|
|
public:
|
|
nsFloatManager(nsIPresShell* aPresShell);
|
|
~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 nsRect GetRegionFor(nsIFrame* aFloatFrame);
|
|
/**
|
|
* 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 nsRect CalculateRegionFor(nsIFrame* aFloatFrame,
|
|
const nsMargin& aMargin);
|
|
/**
|
|
* 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(nsIFrame* aFloat, nsRect& aRegion);
|
|
|
|
// Structure that stores the current state of a frame manager for
|
|
// Save/Restore purposes.
|
|
struct SavedState;
|
|
friend struct SavedState;
|
|
struct SavedState {
|
|
private:
|
|
PRUint32 mFloatInfoCount;
|
|
nscoord mX, mY;
|
|
bool mPushedLeftFloatPastBreak;
|
|
bool mPushedRightFloatPastBreak;
|
|
bool mSplitLeftFloatAcrossBreak;
|
|
bool mSplitRightFloatAcrossBreak;
|
|
|
|
friend class nsFloatManager;
|
|
};
|
|
|
|
/**
|
|
* Translate the current origin by the specified (dx, dy). This
|
|
* creates a new local coordinate space relative to the current
|
|
* coordinate space.
|
|
*/
|
|
void Translate(nscoord aDx, nscoord aDy) { mX += aDx; mY += aDy; }
|
|
|
|
/**
|
|
* Returns the current translation from local coordinate space to
|
|
* world coordinate space. This represents the accumulated calls to
|
|
* Translate().
|
|
*/
|
|
void GetTranslation(nscoord& aX, nscoord& aY) const { aX = mX; aY = mY; }
|
|
|
|
/**
|
|
* Get information about the area available to content that flows
|
|
* around floats. Two different types of space can be requested:
|
|
* BAND_FROM_POINT: returns the band containing vertical coordinate
|
|
* |aY| (though actually with the top truncated to begin at aY),
|
|
* but up to at most |aHeight| (which may be nscoord_MAX).
|
|
* This will return the tallest rectangle whose top is |aY| and in
|
|
* which there are no changes in what floats are on the sides of
|
|
* that rectangle, but will limit the height of the rectangle to
|
|
* |aHeight|. The left and right edges of the rectangle give the
|
|
* area available for line boxes in that space. The width of this
|
|
* resulting rectangle will not be negative.
|
|
* WIDTH_WITHIN_HEIGHT: This returns a rectangle whose top is aY and
|
|
* whose height is exactly aHeight. Its left and right edges give
|
|
* the left and right edges of the space that can be used for line
|
|
* boxes *throughout* that space. (It is possible that more
|
|
* horizontal space could be used in part of the space if a float
|
|
* begins or ends in it.) The width of the resulting rectangle
|
|
* can be negative.
|
|
*
|
|
* @param aY [in] vertical coordinate for top of available space
|
|
* desired
|
|
* @param aHeight [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 horizontal bounds, but may be
|
|
* narrower when floats are present.
|
|
* mBandHasFloats is whether there are floats at the sides of the
|
|
* return value including those that do not reduce the line box
|
|
* width at all (because they are entirely in the margins)
|
|
*
|
|
* aY and aAvailSpace are positioned relative to the current translation
|
|
*/
|
|
enum BandInfoType { BAND_FROM_POINT, WIDTH_WITHIN_HEIGHT };
|
|
nsFlowAreaRect GetFlowArea(nscoord aY, BandInfoType aInfoType,
|
|
nscoord aHeight, nsRect aContentArea,
|
|
SavedState* aState) const;
|
|
|
|
/**
|
|
* Add a float that comes after all floats previously added. Its top
|
|
* 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.
|
|
*/
|
|
nsresult AddFloat(nsIFrame* aFloatFrame, const nsRect& aMarginRect);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
private:
|
|
struct FloatInfo;
|
|
public:
|
|
|
|
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 + mY, aIntervalEnd + mY);
|
|
}
|
|
|
|
bool IntersectsDamage(nscoord aIntervalBegin, nscoord aIntervalEnd) const
|
|
{
|
|
return mFloatDamage.Intersects(aIntervalBegin + mY, aIntervalEnd + mY);
|
|
}
|
|
|
|
/**
|
|
* 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 top 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 aY if there are no matching floats.
|
|
*
|
|
* Both aY 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 aY, PRUint8 aBreakType, PRUint32 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(PRUint8 aBreakType) const;
|
|
|
|
void AssertStateMatches(SavedState *aState) const
|
|
{
|
|
NS_ASSERTION(aState->mX == mX && aState->mY == mY &&
|
|
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
|
|
/**
|
|
* Dump the state of the float manager out to a file.
|
|
*/
|
|
nsresult List(FILE* out) const;
|
|
#endif
|
|
|
|
private:
|
|
|
|
struct FloatInfo {
|
|
nsIFrame *const mFrame;
|
|
nsRect mRect;
|
|
// The lowest bottoms of left/right floats up to and including this one.
|
|
nscoord mLeftYMost, mRightYMost;
|
|
|
|
FloatInfo(nsIFrame* aFrame, const nsRect& aRect);
|
|
#ifdef NS_BUILD_REFCNT_LOGGING
|
|
FloatInfo(const FloatInfo& aOther);
|
|
~FloatInfo();
|
|
#endif
|
|
};
|
|
|
|
nscoord mX, mY; // translation from local to global coordinate space
|
|
nsTArray<FloatInfo> 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 PRInt32 sCachedFloatManagerCount;
|
|
static void* sCachedFloatManagers[NS_FLOAT_MANAGER_CACHE_SIZE];
|
|
|
|
nsFloatManager(const nsFloatManager&) MOZ_DELETE;
|
|
void operator=(const nsFloatManager&) MOZ_DELETE;
|
|
};
|
|
|
|
/**
|
|
* A helper class to manage maintenance of the float manager during
|
|
* nsBlockFrame::Reflow. It automatically restores the old float
|
|
* manager in the reflow state when the object goes out of scope.
|
|
*/
|
|
class nsAutoFloatManager {
|
|
public:
|
|
nsAutoFloatManager(nsHTMLReflowState& aReflowState)
|
|
: mReflowState(aReflowState),
|
|
mNew(nsnull),
|
|
mOld(nsnull) {}
|
|
|
|
~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 state.
|
|
*/
|
|
nsresult
|
|
CreateFloatManager(nsPresContext *aPresContext);
|
|
|
|
protected:
|
|
nsHTMLReflowState &mReflowState;
|
|
nsFloatManager *mNew;
|
|
nsFloatManager *mOld;
|
|
};
|
|
|
|
#endif /* !defined(nsFloatManager_h_) */
|