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

--1:000000000000
+:edc09586110b
+/* -*- 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/. */
+/* rendering object for css3 multi-column layout */
+#include "mozilla/Attributes.h"
+#include "nsContainerFrame.h"
+class nsColumnSetFrame : public nsContainerFrame {
+public:
+NS_DECL_FRAMEARENA_HELPERS
+nsColumnSetFrame(nsStyleContext* aContext);
+virtual nsresult SetInitialChildList(ChildListID     aListID,
+nsFrameList&    aChildList) MOZ_OVERRIDE;
+virtual nsresult Reflow(nsPresContext* aPresContext,
+nsHTMLReflowMetrics& aDesiredSize,
+const nsHTMLReflowState& aReflowState,
+nsReflowStatus& aStatus) MOZ_OVERRIDE;
+virtual nsresult  AppendFrames(ChildListID     aListID,
+nsFrameList&    aFrameList) MOZ_OVERRIDE;
+virtual nsresult  InsertFrames(ChildListID     aListID,
+nsIFrame*       aPrevFrame,
+nsFrameList&    aFrameList) MOZ_OVERRIDE;
+virtual nsresult  RemoveFrame(ChildListID     aListID,
+nsIFrame*       aOldFrame) MOZ_OVERRIDE;
+virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
+virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
+/**
+* Retrieve the available height for content of this frame. The available content
+* height is the available height for the frame, minus borders and padding.
+*/
+virtual nscoord GetAvailableContentHeight(const nsHTMLReflowState& aReflowState);
+virtual nsIFrame* GetContentInsertionFrame() MOZ_OVERRIDE {
+nsIFrame* frame = GetFirstPrincipalChild();
+// if no children return nullptr
+if (!frame)
+return nullptr;
+return frame->GetContentInsertionFrame();
+}
+virtual nsresult StealFrame(nsIFrame* aChild, bool aForceNormal) MOZ_OVERRIDE
+{ // nsColumnSetFrame keeps overflow containers in main child list
+return nsContainerFrame::StealFrame(aChild, true);
+}
+virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
+{
+return nsContainerFrame::IsFrameOfType(aFlags &
+~(nsIFrame::eCanContainOverflowContainers));
+}
+virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+const nsRect&           aDirtyRect,
+const nsDisplayListSet& aLists) MOZ_OVERRIDE;
+virtual nsIAtom* GetType() const MOZ_OVERRIDE;
+virtual void PaintColumnRule(nsRenderingContext* aCtx,
+const nsRect&        aDirtyRect,
+const nsPoint&       aPt);
+#ifdef DEBUG_FRAME_DUMP
+virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE {
+return MakeFrameName(NS_LITERAL_STRING("ColumnSet"), aResult);
+}
+#endif
+protected:
+nscoord        mLastBalanceHeight;
+nsReflowStatus mLastFrameStatus;
+/**
+* These are the parameters that control the layout of columns.
+*/
+struct ReflowConfig {
+// The number of columns that we want to balance across. If we're not
+// balancing, this will be set to INT32_MAX.
+int32_t mBalanceColCount;
+// The width of each individual column.
+nscoord mColWidth;
+// The amount of width that is expected to be left over after all the
+// columns and column gaps are laid out.
+nscoord mExpectedWidthLeftOver;
+// The width of each column gap.
+nscoord mColGap;
+// The maximum height of any individual column during a reflow iteration.
+// This parameter is set during each iteration of the binary search for
+// the best column height.
+nscoord mColMaxHeight;
+// A boolean controlling whether or not we are balancing. This should be
+// equivalent to mBalanceColCount == INT32_MAX.
+bool mIsBalancing;
+// The last known column height that was 'feasible'. A column height is
+// feasible if all child content fits within the specified height.
+nscoord mKnownFeasibleHeight;
+// The last known height that was 'infeasible'. A column height is
+// infeasible if not all child content fits within the specified height.
+nscoord mKnownInfeasibleHeight;
+// Height of the column set frame
+nscoord mComputedHeight;
+// The height "consumed" by previous-in-flows.
+// The computed height should be equal to the height of the element (i.e.
+// the computed height itself) plus the consumed height.
+nscoord mConsumedHeight;
+};
+/**
+* Some data that is better calculated during reflow
+*/
+struct ColumnBalanceData {
+// The maximum "content height" of any column
+nscoord mMaxHeight;
+// The sum of the "content heights" for all columns
+nscoord mSumHeight;
+// The "content height" of the last column
+nscoord mLastHeight;
+// The maximum "content height" of all columns that overflowed
+// their available height
+nscoord mMaxOverflowingHeight;
+// This flag determines whether the last reflow of children exceeded the
+// computed height of the column set frame. If so, we set the height to
+// this maximum allowable height, and continue reflow without balancing.
+bool mHasExcessHeight;
+void Reset() {
+mMaxHeight = mSumHeight = mLastHeight = mMaxOverflowingHeight = 0;
+mHasExcessHeight = false;
+}
+};
+/**
+* Similar to nsBlockFrame::DrainOverflowLines. Locate any columns not
+* handled by our prev-in-flow, and any columns sitting on our own
+* overflow list, and put them in our primary child list for reflowing.
+*/
+void DrainOverflowColumns();
+bool ReflowColumns(nsHTMLReflowMetrics& aDesiredSize,
+const nsHTMLReflowState& aReflowState,
+nsReflowStatus& aReflowStatus,
+ReflowConfig& aConfig,
+bool aLastColumnUnbounded,
+nsCollapsingMargin* aCarriedOutBottomMargin,
+ColumnBalanceData& aColData);
+/**
+* The basic reflow strategy is to call this function repeatedly to
+* obtain specific parameters that determine the layout of the
+* columns. This function will compute those parameters from the CSS
+* style. This function will also be responsible for implementing
+* the state machine that controls column balancing.
+*/
+ReflowConfig ChooseColumnStrategy(const nsHTMLReflowState& aReflowState,
+bool aForceAuto, nscoord aFeasibleHeight,
+nscoord aInfeasibleHeight);
+/**
+* Perform the binary search for the best balance height for this column set.
+*
+* @param aReflowState The input parameters for the current reflow iteration.
+* @param aPresContext The presentation context in which the current reflow
+*        iteration is occurring.
+* @param aConfig The ReflowConfig object associated with this column set
+*        frame, generated by ChooseColumnStrategy().
+* @param aColData A data structure used to keep track of data needed between
+*        successive iterations of the balancing process.
+* @param aDesiredSize The final output size of the column set frame (output
+*        of reflow procedure).
+* @param aOutMargin The bottom margin of the column set frame that may be
+*        carried out from reflow (and thus collapsed).
+* @param aUnboundedLastColumn A boolean value indicating that the last column
+*        can be of any height. Used during the first iteration of the
+*        balancing procedure to measure the height of all content in
+*        descendant frames of the column set.
+* @param aRunWasFeasible An input/output parameter indicating whether or not
+*        the last iteration of the balancing loop was a feasible height to
+*        fit all content from descendant frames.
+* @param aStatus A final reflow status of the column set frame, passed in as
+*        an output parameter.
+*/
+void FindBestBalanceHeight(const nsHTMLReflowState& aReflowState,
+nsPresContext* aPresContext,
+ReflowConfig& aConfig,
+ColumnBalanceData& aColData,
+nsHTMLReflowMetrics& aDesiredSize,
+nsCollapsingMargin& aOutMargin,
+bool& aUnboundedLastColumn,
+bool& aRunWasFeasible,
+nsReflowStatus& aStatus);
+/**
+* Reflow column children. Returns true iff the content that was reflowed
+* fit into the mColMaxHeight.
+*/
+bool ReflowChildren(nsHTMLReflowMetrics& aDesiredSize,
+const nsHTMLReflowState& aReflowState,
+nsReflowStatus& aStatus,
+const ReflowConfig& aConfig,
+bool aLastColumnUnbounded,
+nsCollapsingMargin* aCarriedOutBottomMargin,
+ColumnBalanceData& aColData);
+};

The Tor Browser / file comparison

comparison: layout/generic/nsColumnSetFrame.h

layout/generic/nsColumnSetFrame.h