The Tor Browser: comparison layout/generic/nsFloatManager.h

--1:000000000000
+:c75576a93d51
+/* -*- 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"
+#include "nsFrameList.h" // for DEBUG_FRAME_DUMP
+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:
+uint32_t 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, uint8_t 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(uint8_t 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_FRAME_DUMP
+/**
+* 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 int32_t 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(nullptr),
+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 state.
+*/
+nsresult
+CreateFloatManager(nsPresContext *aPresContext);
+protected:
+nsHTMLReflowState &mReflowState;
+nsFloatManager *mNew;
+nsFloatManager *mOld;
+};
+#endif /* !defined(nsFloatManager_h_) */

The Tor Browser / file comparison

comparison: layout/generic/nsFloatManager.h

layout/generic/nsFloatManager.h