diff options
Diffstat (limited to 'layout/xul/nsBoxFrame.cpp')
| -rw-r--r-- | layout/xul/nsBoxFrame.cpp | 1035 |
1 files changed, 1035 insertions, 0 deletions
diff --git a/layout/xul/nsBoxFrame.cpp b/layout/xul/nsBoxFrame.cpp new file mode 100644 index 0000000000..4a547dda98 --- /dev/null +++ b/layout/xul/nsBoxFrame.cpp @@ -0,0 +1,1035 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +// +// Eric Vaughan +// Netscape Communications +// +// See documentation in associated header file +// + +// How boxes layout +// ---------------- +// Boxes layout a bit differently than html. html does a bottom up layout. Where +// boxes do a top down. +// +// 1) First thing a box does it goes out and askes each child for its min, max, +// and preferred sizes. +// +// 2) It then adds them up to determine its size. +// +// 3) If the box was asked to layout it self intrinically it will layout its +// children at their preferred size otherwise it will layout the child at +// the size it was told to. It will squeeze or stretch its children if +// Necessary. +// +// However there is a catch. Some html components like block frames can not +// determine their preferred size. this is their size if they were laid out +// intrinsically. So the box will flow the child to determine this can cache the +// value. + +// Boxes and Incremental Reflow +// ---------------------------- +// Boxes layout out top down by adding up their children's min, max, and +// preferred sizes. Only problem is if a incremental reflow occurs. The +// preferred size of a child deep in the hierarchy could change. And this could +// change any number of syblings around the box. Basically any children in the +// reflow chain must have their caches cleared so when asked for there current +// size they can relayout themselves. + +#include "nsBoxFrame.h" + +#include <algorithm> +#include <utility> + +#include "gfxUtils.h" +#include "mozilla/ComputedStyle.h" +#include "mozilla/CSSOrderAwareFrameIterator.h" +#include "mozilla/Preferences.h" +#include "mozilla/PresShell.h" +#include "mozilla/dom/Touch.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/gfxVars.h" +#include "nsBoxLayout.h" +#include "nsBoxLayoutState.h" +#include "nsCOMPtr.h" +#include "nsCSSAnonBoxes.h" +#include "nsCSSRendering.h" +#include "nsContainerFrame.h" +#include "nsDisplayList.h" +#include "nsGkAtoms.h" +#include "nsHTMLParts.h" +#include "nsIContent.h" +#include "nsIFrameInlines.h" +#include "nsIScrollableFrame.h" +#include "nsITheme.h" +#include "nsIWidget.h" +#include "nsLayoutUtils.h" +#include "nsNameSpaceManager.h" +#include "nsPlaceholderFrame.h" +#include "nsPresContext.h" +#include "nsSliderFrame.h" +#include "nsSprocketLayout.h" +#include "nsStyleConsts.h" +#include "nsTransform2D.h" +#include "nsView.h" +#include "nsViewManager.h" +#include "nsWidgetsCID.h" + +// Needed for Print Preview + +#include "mozilla/TouchEvents.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::gfx; + +nsContainerFrame* NS_NewBoxFrame(PresShell* aPresShell, ComputedStyle* aStyle) { + return new (aPresShell) nsBoxFrame(aStyle, aPresShell->GetPresContext()); +} + +NS_IMPL_FRAMEARENA_HELPERS(nsBoxFrame) + +#ifdef DEBUG +NS_QUERYFRAME_HEAD(nsBoxFrame) + NS_QUERYFRAME_ENTRY(nsBoxFrame) +NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) +#endif + +nsBoxFrame::nsBoxFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, + ClassID aID) + : nsContainerFrame(aStyle, aPresContext, aID), mAscent(0) { + AddStateBits(NS_STATE_IS_HORIZONTAL | NS_STATE_AUTO_STRETCH); + + mValign = vAlign_Top; + mHalign = hAlign_Left; + + // Use the static sprocket layout + nsCOMPtr<nsBoxLayout> layout; + NS_NewSprocketLayout(layout); + SetXULLayoutManager(layout); +} + +nsBoxFrame::~nsBoxFrame() = default; + +nsIFrame* nsBoxFrame::SlowOrdinalGroupAwareSibling(nsIFrame* aBox, bool aNext) { + nsIFrame* parent = aBox->GetParent(); + if (!parent) { + return nullptr; + } + CSSOrderAwareFrameIterator iter( + parent, FrameChildListID::Principal, + CSSOrderAwareFrameIterator::ChildFilter::IncludeAll, + CSSOrderAwareFrameIterator::OrderState::Unknown, + CSSOrderAwareFrameIterator::OrderingProperty::BoxOrdinalGroup); + + nsIFrame* prevSibling = nullptr; + for (; !iter.AtEnd(); iter.Next()) { + nsIFrame* current = iter.get(); + if (!aNext && current == aBox) { + return prevSibling; + } + if (aNext && prevSibling == aBox) { + return current; + } + prevSibling = current; + } + return nullptr; +} + +void nsBoxFrame::SetInitialChildList(ChildListID aListID, + nsFrameList&& aChildList) { + nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList)); + if (aListID == FrameChildListID::Principal) { + // initialize our list of infos. + nsBoxLayoutState state(PresContext()); + if (mLayoutManager) + mLayoutManager->ChildrenSet(this, state, mFrames.FirstChild()); + } +} + +/* virtual */ +void nsBoxFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) { + nsContainerFrame::DidSetComputedStyle(aOldComputedStyle); + + // The values that CacheAttributes() computes depend on our style, + // so we need to recompute them here... + CacheAttributes(); +} + +/** + * Initialize us. This is a good time to get the alignment of the box + */ +void nsBoxFrame::Init(nsIContent* aContent, nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) { + nsContainerFrame::Init(aContent, aParent, aPrevInFlow); + + if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_CONTAINER)) { + AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT); + } + + MarkIntrinsicISizesDirty(); + + CacheAttributes(); +} + +void nsBoxFrame::CacheAttributes() { + /* + printf("Caching: "); + XULDumpBox(stdout); + printf("\n"); + */ + + mValign = vAlign_Top; + mHalign = hAlign_Left; + + bool orient = false; + GetInitialOrientation(orient); + if (orient) + AddStateBits(NS_STATE_IS_HORIZONTAL); + else + RemoveStateBits(NS_STATE_IS_HORIZONTAL); + + bool normal = true; + GetInitialDirection(normal); + if (normal) + AddStateBits(NS_STATE_IS_DIRECTION_NORMAL); + else + RemoveStateBits(NS_STATE_IS_DIRECTION_NORMAL); + + GetInitialVAlignment(mValign); + GetInitialHAlignment(mHalign); + + bool autostretch = !!(mState & NS_STATE_AUTO_STRETCH); + GetInitialAutoStretch(autostretch); + if (autostretch) + AddStateBits(NS_STATE_AUTO_STRETCH); + else + RemoveStateBits(NS_STATE_AUTO_STRETCH); +} + +bool nsBoxFrame::GetInitialHAlignment(nsBoxFrame::Halignment& aHalign) { + if (!GetContent()) return false; + + // For horizontal boxes we're checking PACK. For vertical boxes we are + // checking ALIGN. + const nsStyleXUL* boxInfo = StyleXUL(); + if (IsXULHorizontal()) { + switch (boxInfo->mBoxPack) { + case StyleBoxPack::Start: + aHalign = nsBoxFrame::hAlign_Left; + return true; + case StyleBoxPack::Center: + aHalign = nsBoxFrame::hAlign_Center; + return true; + case StyleBoxPack::End: + aHalign = nsBoxFrame::hAlign_Right; + return true; + default: // Nonsensical value. Just bail. + return false; + } + } else { + switch (boxInfo->mBoxAlign) { + case StyleBoxAlign::Start: + aHalign = nsBoxFrame::hAlign_Left; + return true; + case StyleBoxAlign::Center: + aHalign = nsBoxFrame::hAlign_Center; + return true; + case StyleBoxAlign::End: + aHalign = nsBoxFrame::hAlign_Right; + return true; + default: // Nonsensical value. Just bail. + return false; + } + } +} + +bool nsBoxFrame::GetInitialVAlignment(nsBoxFrame::Valignment& aValign) { + if (!GetContent()) return false; + // For horizontal boxes we're checking ALIGN. For vertical boxes we are + // checking PACK. + const nsStyleXUL* boxInfo = StyleXUL(); + if (IsXULHorizontal()) { + switch (boxInfo->mBoxAlign) { + case StyleBoxAlign::Start: + aValign = nsBoxFrame::vAlign_Top; + return true; + case StyleBoxAlign::Center: + aValign = nsBoxFrame::vAlign_Middle; + return true; + case StyleBoxAlign::Baseline: + aValign = nsBoxFrame::vAlign_BaseLine; + return true; + case StyleBoxAlign::End: + aValign = nsBoxFrame::vAlign_Bottom; + return true; + default: // Nonsensical value. Just bail. + return false; + } + } else { + switch (boxInfo->mBoxPack) { + case StyleBoxPack::Start: + aValign = nsBoxFrame::vAlign_Top; + return true; + case StyleBoxPack::Center: + aValign = nsBoxFrame::vAlign_Middle; + return true; + case StyleBoxPack::End: + aValign = nsBoxFrame::vAlign_Bottom; + return true; + default: // Nonsensical value. Just bail. + return false; + } + } +} + +void nsBoxFrame::GetInitialOrientation(bool& aIsHorizontal) { + // see if we are a vertical or horizontal box. + if (!GetContent()) return; + + const nsStyleXUL* boxInfo = StyleXUL(); + if (boxInfo->mBoxOrient == StyleBoxOrient::Horizontal) { + aIsHorizontal = true; + } else { + aIsHorizontal = false; + } +} + +void nsBoxFrame::GetInitialDirection(bool& aIsNormal) { + if (!GetContent()) return; + + if (IsXULHorizontal()) { + // For horizontal boxes only, we initialize our value based off the CSS + // 'direction' property. This means that BiDI users will end up with + // horizontally inverted chrome. + // + // If text runs RTL then so do we. + aIsNormal = StyleVisibility()->mDirection == StyleDirection::Ltr; + if (GetContent()->IsElement()) { + Element* element = GetContent()->AsElement(); + + // Now see if we have an attribute. The attribute overrides + // the style system 'direction' property. + static Element::AttrValuesArray strings[] = {nsGkAtoms::ltr, + nsGkAtoms::rtl, nullptr}; + int32_t index = element->FindAttrValueIn( + kNameSpaceID_None, nsGkAtoms::dir, strings, eCaseMatters); + if (index >= 0) { + bool values[] = {true, false}; + aIsNormal = values[index]; + } + } + } else { + aIsNormal = true; // Assume a normal direction in the vertical case. + } + + // Now check the style system to see if we should invert aIsNormal. + const nsStyleXUL* boxInfo = StyleXUL(); + if (boxInfo->mBoxDirection == StyleBoxDirection::Reverse) { + aIsNormal = !aIsNormal; // Invert our direction. + } +} + +/* Returns true if it was set. + */ +bool nsBoxFrame::GetInitialAutoStretch(bool& aStretch) { + if (!GetContent()) return false; + + // Check the CSS box-align property. + const nsStyleXUL* boxInfo = StyleXUL(); + aStretch = (boxInfo->mBoxAlign == StyleBoxAlign::Stretch); + + return true; +} + +void nsBoxFrame::DidReflow(nsPresContext* aPresContext, + const ReflowInput* aReflowInput) { + nsFrameState preserveBits = + mState & (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN); + nsIFrame::DidReflow(aPresContext, aReflowInput); + AddStateBits(preserveBits); + if (preserveBits & NS_FRAME_IS_DIRTY) { + this->MarkSubtreeDirty(); + } +} + +bool nsBoxFrame::HonorPrintBackgroundSettings() const { + return !mContent->IsInNativeAnonymousSubtree() && + nsContainerFrame::HonorPrintBackgroundSettings(); +} + +#ifdef DO_NOISY_REFLOW +static int myCounter = 0; +static void printSize(char* aDesc, nscoord aSize) { + printf(" %s: ", aDesc); + if (aSize == NS_UNCONSTRAINEDSIZE) { + printf("UC"); + } else { + printf("%d", aSize); + } +} +#endif + +/* virtual */ +nscoord nsBoxFrame::GetMinISize(gfxContext* aRenderingContext) { + nscoord result; + DISPLAY_MIN_INLINE_SIZE(this, result); + + nsBoxLayoutState state(PresContext(), aRenderingContext); + nsSize minSize = GetXULMinSize(state); + + // GetXULMinSize returns border-box width, and we want to return content + // width. Since Reflow uses the reflow input's border and padding, we + // actually just want to subtract what GetXULMinSize added, which is the + // result of GetXULBorderAndPadding. + nsMargin bp; + GetXULBorderAndPadding(bp); + + result = minSize.width - bp.LeftRight(); + result = std::max(result, 0); + + return result; +} + +/* virtual */ +nscoord nsBoxFrame::GetPrefISize(gfxContext* aRenderingContext) { + nscoord result; + DISPLAY_PREF_INLINE_SIZE(this, result); + + nsBoxLayoutState state(PresContext(), aRenderingContext); + nsSize prefSize = GetXULPrefSize(state); + + // GetXULPrefSize returns border-box width, and we want to return content + // width. Since Reflow uses the reflow input's border and padding, we + // actually just want to subtract what GetXULPrefSize added, which is the + // result of GetXULBorderAndPadding. + nsMargin bp; + GetXULBorderAndPadding(bp); + + result = prefSize.width - bp.LeftRight(); + result = std::max(result, 0); + + return result; +} + +void nsBoxFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) { + MarkInReflow(); + // If you make changes to this method, please keep nsLeafBoxFrame::Reflow + // in sync, if the changes are applicable there. + + DO_GLOBAL_REFLOW_COUNT("nsBoxFrame"); + DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus); + MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!"); + + NS_ASSERTION( + aReflowInput.ComputedWidth() >= 0 && aReflowInput.ComputedHeight() >= 0, + "Computed Size < 0"); + +#ifdef DO_NOISY_REFLOW + printf( + "\n-------------Starting BoxFrame Reflow ----------------------------\n"); + printf("%p ** nsBF::Reflow %d ", this, myCounter++); + + printSize("AW", aReflowInput.AvailableWidth()); + printSize("AH", aReflowInput.AvailableHeight()); + printSize("CW", aReflowInput.ComputedWidth()); + printSize("CH", aReflowInput.ComputedHeight()); + + printf(" *\n"); + +#endif + + // create the layout state + nsBoxLayoutState state(aPresContext, aReflowInput.mRenderingContext, + &aReflowInput, aReflowInput.mReflowDepth); + + WritingMode wm = aReflowInput.GetWritingMode(); + LogicalSize computedSize = aReflowInput.ComputedSize(); + + LogicalMargin m = aReflowInput.ComputedLogicalBorderPadding(wm); + // GetXULBorderAndPadding(m); + + LogicalSize prefSize(wm); + + // if we are told to layout intrinsic then get our preferred size. + NS_ASSERTION(computedSize.ISize(wm) != NS_UNCONSTRAINEDSIZE, + "computed inline size should always be computed"); + if (computedSize.BSize(wm) == NS_UNCONSTRAINEDSIZE) { + nsSize physicalPrefSize = GetXULPrefSize(state); + nsSize minSize = GetXULMinSize(state); + nsSize maxSize = GetXULMaxSize(state); + // XXXbz isn't GetXULPrefSize supposed to bounds-check for us? + physicalPrefSize = XULBoundsCheck(minSize, physicalPrefSize, maxSize); + prefSize = LogicalSize(wm, physicalPrefSize); + } + + // get our desiredSize + computedSize.ISize(wm) += m.IStart(wm) + m.IEnd(wm); + + if (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE) { + computedSize.BSize(wm) = prefSize.BSize(wm); + // prefSize is border-box but min/max constraints are content-box. + nscoord blockDirBorderPadding = + aReflowInput.ComputedLogicalBorderPadding(wm).BStartEnd(wm); + nscoord contentBSize = computedSize.BSize(wm) - blockDirBorderPadding; + // Note: contentHeight might be negative, but that's OK because min-height + // is never negative. + computedSize.BSize(wm) = + aReflowInput.ApplyMinMaxHeight(contentBSize) + blockDirBorderPadding; + } else { + computedSize.BSize(wm) += m.BStart(wm) + m.BEnd(wm); + } + + nsSize physicalSize = computedSize.GetPhysicalSize(wm); + nsRect r(mRect.x, mRect.y, physicalSize.width, physicalSize.height); + + SetXULBounds(state, r); + + // layout our children + XULLayout(state); + + // ok our child could have gotten bigger. So lets get its bounds + + // get the ascent + LogicalSize boxSize = GetLogicalSize(wm); + nscoord ascent = boxSize.BSize(wm); + + // getting the ascent could be a lot of work. Don't get it if + // we are the root. The viewport doesn't care about it. + if (!Style()->IsRootElementStyle()) { + ascent = GetXULBoxAscent(state); + } + + aDesiredSize.SetSize(wm, boxSize); + aDesiredSize.SetBlockStartAscent(ascent); + + aDesiredSize.mOverflowAreas = GetOverflowAreas(); + +#ifdef DO_NOISY_REFLOW + { + printf("%p ** nsBF(done) W:%d H:%d ", this, aDesiredSize.Width(), + aDesiredSize.Height()); + + if (maxElementSize) { + printf("MW:%d\n", *maxElementWidth); + } else { + printf("MW:?\n"); + } + } +#endif + + ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus); +} + +nsSize nsBoxFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) { + NS_ASSERTION(aBoxLayoutState.GetRenderingContext(), + "must have rendering context"); + + nsSize size(0, 0); + DISPLAY_PREF_SIZE(this, size); + if (!XULNeedsRecalc(mPrefSize)) { + size = mPrefSize; + return size; + } + + if (IsXULCollapsed()) return size; + + // if the size was not completely redefined in CSS then ask our children + bool widthSet, heightSet; + if (!nsIFrame::AddXULPrefSize(this, size, widthSet, heightSet)) { + if (mLayoutManager) { + nsSize layoutSize = mLayoutManager->GetXULPrefSize(this, aBoxLayoutState); + if (!widthSet) size.width = layoutSize.width; + if (!heightSet) size.height = layoutSize.height; + } else { + size = nsIFrame::GetUncachedXULPrefSize(aBoxLayoutState); + } + } + + nsSize minSize = GetXULMinSize(aBoxLayoutState); + nsSize maxSize = GetXULMaxSize(aBoxLayoutState); + mPrefSize = XULBoundsCheck(minSize, size, maxSize); + + return mPrefSize; +} + +nscoord nsBoxFrame::GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) { + if (!XULNeedsRecalc(mAscent)) { + return mAscent; + } + + if (IsXULCollapsed()) { + return 0; + } + + if (mLayoutManager) { + mAscent = mLayoutManager->GetAscent(this, aBoxLayoutState); + } else { + mAscent = GetXULPrefSize(aBoxLayoutState).height; + } + + return mAscent; +} + +nsSize nsBoxFrame::GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) { + NS_ASSERTION(aBoxLayoutState.GetRenderingContext(), + "must have rendering context"); + + nsSize size(0, 0); + DISPLAY_MIN_SIZE(this, size); + if (!XULNeedsRecalc(mMinSize)) { + size = mMinSize; + return size; + } + + if (IsXULCollapsed()) return size; + + // if the size was not completely redefined in CSS then ask our children + bool widthSet, heightSet; + if (!nsIFrame::AddXULMinSize(this, size, widthSet, heightSet)) { + if (mLayoutManager) { + nsSize layoutSize = mLayoutManager->GetXULMinSize(this, aBoxLayoutState); + if (!widthSet) size.width = layoutSize.width; + if (!heightSet) size.height = layoutSize.height; + } else { + size = nsIFrame::GetUncachedXULMinSize(aBoxLayoutState); + } + } + + mMinSize = size; + + return size; +} + +nsSize nsBoxFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) { + NS_ASSERTION(aBoxLayoutState.GetRenderingContext(), + "must have rendering context"); + + nsSize size(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE); + DISPLAY_MAX_SIZE(this, size); + if (!XULNeedsRecalc(mMaxSize)) { + size = mMaxSize; + return size; + } + + if (IsXULCollapsed()) return size; + + // if the size was not completely redefined in CSS then ask our children + bool widthSet, heightSet; + if (!nsIFrame::AddXULMaxSize(this, size, widthSet, heightSet)) { + if (mLayoutManager) { + nsSize layoutSize = mLayoutManager->GetXULMaxSize(this, aBoxLayoutState); + if (!widthSet) size.width = layoutSize.width; + if (!heightSet) size.height = layoutSize.height; + } else { + size = nsIFrame::GetUncachedXULMaxSize(aBoxLayoutState); + } + } + + mMaxSize = size; + + return size; +} + +/** + * If subclassing please subclass this method not layout. + * layout will call this method. + */ +NS_IMETHODIMP +nsBoxFrame::DoXULLayout(nsBoxLayoutState& aState) { + ReflowChildFlags oldFlags = aState.LayoutFlags(); + aState.SetLayoutFlags(ReflowChildFlags::Default); + + nsresult rv = NS_OK; + if (mLayoutManager) { + XULCoordNeedsRecalc(mAscent); + rv = mLayoutManager->XULLayout(this, aState); + } + + aState.SetLayoutFlags(oldFlags); + + if (HasAbsolutelyPositionedChildren()) { + // Set up a |reflowInput| to pass into ReflowAbsoluteFrames + WritingMode wm = GetWritingMode(); + ReflowInput reflowInput( + aState.PresContext(), this, aState.GetRenderingContext(), + LogicalSize(wm, GetLogicalSize().ISize(wm), NS_UNCONSTRAINEDSIZE)); + + // Set up a |desiredSize| to pass into ReflowAbsoluteFrames + ReflowOutput desiredSize(reflowInput); + desiredSize.Width() = mRect.width; + desiredSize.Height() = mRect.height; + + // get the ascent (cribbed from ::Reflow) + nscoord ascent = mRect.height; + + // getting the ascent could be a lot of work. Don't get it if + // we are the root. The viewport doesn't care about it. + if (!Style()->IsRootElementStyle()) { + ascent = GetXULBoxAscent(aState); + } + desiredSize.SetBlockStartAscent(ascent); + desiredSize.mOverflowAreas = GetOverflowAreas(); + + AddStateBits(NS_FRAME_IN_REFLOW); + // Set up a |reflowStatus| to pass into ReflowAbsoluteFrames + // (just a dummy value; hopefully that's OK) + nsReflowStatus reflowStatus; + ReflowAbsoluteFrames(aState.PresContext(), desiredSize, reflowInput, + reflowStatus); + RemoveStateBits(NS_FRAME_IN_REFLOW); + } + + return rv; +} + +void nsBoxFrame::DestroyFrom(nsIFrame* aDestructRoot, + PostDestroyData& aPostDestroyData) { + // clean up the container box's layout manager and child boxes + SetXULLayoutManager(nullptr); + + nsContainerFrame::DestroyFrom(aDestructRoot, aPostDestroyData); +} + +/* virtual */ +void nsBoxFrame::MarkIntrinsicISizesDirty() { + XULSizeNeedsRecalc(mPrefSize); + XULSizeNeedsRecalc(mMinSize); + XULSizeNeedsRecalc(mMaxSize); + XULCoordNeedsRecalc(mAscent); + + if (mLayoutManager) { + nsBoxLayoutState state(PresContext()); + mLayoutManager->IntrinsicISizesDirty(this, state); + } + + nsContainerFrame::MarkIntrinsicISizesDirty(); +} + +void nsBoxFrame::RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) { + MOZ_ASSERT(aListID == FrameChildListID::Principal, + "We don't support out-of-flow kids"); + + nsPresContext* presContext = PresContext(); + nsBoxLayoutState state(presContext); + + // remove the child frame + mFrames.RemoveFrame(aOldFrame); + + // notify the layout manager + if (mLayoutManager) mLayoutManager->ChildrenRemoved(this, state, aOldFrame); + + // destroy the child frame + aOldFrame->Destroy(); + + // mark us dirty and generate a reflow command + PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors, + NS_FRAME_HAS_DIRTY_CHILDREN); +} + +void nsBoxFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame, + const nsLineList::iterator* aPrevFrameLine, + nsFrameList&& aFrameList) { + NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this, + "inserting after sibling frame with different parent"); + NS_ASSERTION(!aPrevFrame || mFrames.ContainsFrame(aPrevFrame), + "inserting after sibling frame not in our child list"); + MOZ_ASSERT(aListID == FrameChildListID::Principal, + "We don't support out-of-flow kids"); + + nsBoxLayoutState state(PresContext()); + + // insert the child frames + const nsFrameList::Slice& newFrames = + mFrames.InsertFrames(this, aPrevFrame, std::move(aFrameList)); + + // notify the layout manager + if (mLayoutManager) + mLayoutManager->ChildrenInserted(this, state, aPrevFrame, newFrames); + + PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors, + NS_FRAME_HAS_DIRTY_CHILDREN); +} + +void nsBoxFrame::AppendFrames(ChildListID aListID, nsFrameList&& aFrameList) { + MOZ_ASSERT(aListID == FrameChildListID::Principal, + "We don't support out-of-flow kids"); + + nsBoxLayoutState state(PresContext()); + + // append the new frames + const nsFrameList::Slice& newFrames = + mFrames.AppendFrames(this, std::move(aFrameList)); + + // notify the layout manager + if (mLayoutManager) mLayoutManager->ChildrenAppended(this, state, newFrames); + + // XXXbz why is this NS_FRAME_FIRST_REFLOW check here? + if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) { + PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors, + NS_FRAME_HAS_DIRTY_CHILDREN); + } +} + +nsresult nsBoxFrame::AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute, + int32_t aModType) { + nsresult rv = + nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); + + // Ignore 'width', 'height', 'screenX', 'screenY' and 'sizemode' on a + // <window>. + if (mContent->IsXULElement(nsGkAtoms::window) && + (nsGkAtoms::width == aAttribute || nsGkAtoms::height == aAttribute || + nsGkAtoms::screenX == aAttribute || nsGkAtoms::screenY == aAttribute || + nsGkAtoms::sizemode == aAttribute)) { + return rv; + } + + if (aAttribute == nsGkAtoms::width || aAttribute == nsGkAtoms::height || + aAttribute == nsGkAtoms::align || aAttribute == nsGkAtoms::valign || + aAttribute == nsGkAtoms::minwidth || aAttribute == nsGkAtoms::maxwidth || + aAttribute == nsGkAtoms::minheight || + aAttribute == nsGkAtoms::maxheight || aAttribute == nsGkAtoms::orient || + aAttribute == nsGkAtoms::pack || aAttribute == nsGkAtoms::dir) { + if (aAttribute == nsGkAtoms::align || aAttribute == nsGkAtoms::valign || + aAttribute == nsGkAtoms::orient || aAttribute == nsGkAtoms::pack || + aAttribute == nsGkAtoms::dir) { + mValign = nsBoxFrame::vAlign_Top; + mHalign = nsBoxFrame::hAlign_Left; + + bool orient = true; + GetInitialOrientation(orient); + if (orient) + AddStateBits(NS_STATE_IS_HORIZONTAL); + else + RemoveStateBits(NS_STATE_IS_HORIZONTAL); + + bool normal = true; + GetInitialDirection(normal); + if (normal) + AddStateBits(NS_STATE_IS_DIRECTION_NORMAL); + else + RemoveStateBits(NS_STATE_IS_DIRECTION_NORMAL); + + GetInitialVAlignment(mValign); + GetInitialHAlignment(mHalign); + + bool autostretch = !!(mState & NS_STATE_AUTO_STRETCH); + GetInitialAutoStretch(autostretch); + if (autostretch) + AddStateBits(NS_STATE_AUTO_STRETCH); + else + RemoveStateBits(NS_STATE_AUTO_STRETCH); + } + + PresShell()->FrameNeedsReflow( + this, IntrinsicDirty::FrameAncestorsAndDescendants, NS_FRAME_IS_DIRTY); + } else if (aAttribute == nsGkAtoms::rows && + mContent->IsXULElement(nsGkAtoms::tree)) { + // Reflow ourselves and all our children if "rows" changes, since + // nsTreeBodyFrame's layout reads this from its parent (this frame). + PresShell()->FrameNeedsReflow( + this, IntrinsicDirty::FrameAncestorsAndDescendants, NS_FRAME_IS_DIRTY); + } + + return rv; +} + +void nsBoxFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + nsDisplayListCollection tempLists(aBuilder); + DisplayBorderBackgroundOutline(aBuilder, aLists); + + BuildDisplayListForChildren(aBuilder, aLists); + + // see if we have to draw a selection frame around this container + DisplaySelectionOverlay(aBuilder, aLists.Content()); +} + +void nsBoxFrame::BuildDisplayListForChildren(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + // Iterate over the children in CSS order. + auto iter = CSSOrderAwareFrameIterator( + this, FrameChildListID::Principal, + CSSOrderAwareFrameIterator::ChildFilter::IncludeAll, + CSSOrderAwareFrameIterator::OrderState::Unknown, + CSSOrderAwareFrameIterator::OrderingProperty::BoxOrdinalGroup); + // Put each child's background onto the BlockBorderBackgrounds list + // to emulate the existing two-layer XUL painting scheme. + nsDisplayListSet set(aLists, aLists.BlockBorderBackgrounds()); + for (; !iter.AtEnd(); iter.Next()) { + BuildDisplayListForChild(aBuilder, iter.get(), set); + } +} + +#ifdef DEBUG_FRAME_DUMP +nsresult nsBoxFrame::GetFrameName(nsAString& aResult) const { + return MakeFrameName(u"Box"_ns, aResult); +} +#endif + +nsresult nsBoxFrame::LayoutChildAt(nsBoxLayoutState& aState, nsIFrame* aBox, + const nsRect& aRect) { + // get the current rect + nsRect oldRect(aBox->GetRect()); + aBox->SetXULBounds(aState, aRect); + + bool layout = aBox->IsSubtreeDirty(); + + if (layout || + (oldRect.width != aRect.width || oldRect.height != aRect.height)) { + return aBox->XULLayout(aState); + } + + return NS_OK; +} + +namespace mozilla { + +/** + * This wrapper class lets us redirect mouse hits from descendant frames + * of a menu to the menu itself, if they didn't specify 'allowevents'. + * + * The wrapper simply turns a hit on a descendant element + * into a hit on the menu itself, unless there is an element between the target + * and the menu with the "allowevents" attribute. + * + * This is used by nsMenuFrame and nsTreeColFrame. + * + * Note that turning a hit on a descendant element into nullptr, so events + * could fall through to the menu background, might be an appealing + * simplification but it would mean slightly strange behaviour in some cases, + * because grabber wrappers can be created for many individual lists and items, + * so the exact fallthrough behaviour would be complex. E.g. an element with + * "allowevents" on top of the Content() list could receive the event even if it + * was covered by a PositionedDescenants() element without "allowevents". It is + * best to never convert a non-null hit into null. + */ +// REVIEW: This is roughly of what nsMenuFrame::GetFrameForPoint used to do. +// I've made 'allowevents' affect child elements because that seems the only +// reasonable thing to do. +class nsDisplayXULEventRedirector final : public nsDisplayWrapList { + public: + nsDisplayXULEventRedirector(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, + nsDisplayItem* aItem, nsIFrame* aTargetFrame) + : nsDisplayWrapList(aBuilder, aFrame, aItem), + mTargetFrame(aTargetFrame) {} + nsDisplayXULEventRedirector(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, + nsDisplayList* aList, nsIFrame* aTargetFrame) + : nsDisplayWrapList(aBuilder, aFrame, aList), + mTargetFrame(aTargetFrame) {} + virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect, + HitTestState* aState, + nsTArray<nsIFrame*>* aOutFrames) override; + virtual bool ShouldFlattenAway(nsDisplayListBuilder* aBuilder) override { + return false; + } + void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override { + GetChildren()->Paint(aBuilder, aCtx, + mFrame->PresContext()->AppUnitsPerDevPixel()); + } + NS_DISPLAY_DECL_NAME("XULEventRedirector", TYPE_XUL_EVENT_REDIRECTOR) + private: + nsIFrame* mTargetFrame; +}; + +void nsDisplayXULEventRedirector::HitTest(nsDisplayListBuilder* aBuilder, + const nsRect& aRect, + HitTestState* aState, + nsTArray<nsIFrame*>* aOutFrames) { + nsTArray<nsIFrame*> outFrames; + mList.HitTest(aBuilder, aRect, aState, &outFrames); + + bool topMostAdded = false; + uint32_t localLength = outFrames.Length(); + + for (uint32_t i = 0; i < localLength; i++) { + for (nsIContent* content = outFrames.ElementAt(i)->GetContent(); + content && content != mTargetFrame->GetContent(); + content = content->GetParent()) { + if (!content->IsElement() || + !content->AsElement()->AttrValueIs(kNameSpaceID_None, + nsGkAtoms::allowevents, + nsGkAtoms::_true, eCaseMatters)) { + continue; + } + + // Events are allowed on 'frame', so let it go. + aOutFrames->AppendElement(outFrames.ElementAt(i)); + topMostAdded = true; + } + + // If there was no hit on the topmost frame or its ancestors, + // add the target frame itself as the first candidate (see bug 562554). + if (!topMostAdded) { + topMostAdded = true; + aOutFrames->AppendElement(mTargetFrame); + } + } +} + +} // namespace mozilla + +class nsXULEventRedirectorWrapper final : public nsDisplayItemWrapper { + public: + explicit nsXULEventRedirectorWrapper(nsIFrame* aTargetFrame) + : mTargetFrame(aTargetFrame) {} + virtual nsDisplayItem* WrapList(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame, + nsDisplayList* aList) override { + return MakeDisplayItem<nsDisplayXULEventRedirector>(aBuilder, aFrame, aList, + mTargetFrame); + } + virtual nsDisplayItem* WrapItem(nsDisplayListBuilder* aBuilder, + nsDisplayItem* aItem) override { + return MakeDisplayItem<nsDisplayXULEventRedirector>( + aBuilder, aItem->Frame(), aItem, mTargetFrame); + } + + private: + nsIFrame* mTargetFrame; +}; + +void nsBoxFrame::WrapListsInRedirector(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aIn, + const nsDisplayListSet& aOut) { + nsXULEventRedirectorWrapper wrapper(this); + wrapper.WrapLists(aBuilder, this, aIn, aOut); +} + +bool nsBoxFrame::GetEventPoint(WidgetGUIEvent* aEvent, nsPoint& aPoint) { + LayoutDeviceIntPoint refPoint; + bool res = GetEventPoint(aEvent, refPoint); + aPoint = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, refPoint, + RelativeTo{this}); + return res; +} + +bool nsBoxFrame::GetEventPoint(WidgetGUIEvent* aEvent, + LayoutDeviceIntPoint& aPoint) { + NS_ENSURE_TRUE(aEvent, false); + + WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent(); + if (touchEvent) { + // return false if there is more than one touch on the page, or if + // we can't find a touch point + if (touchEvent->mTouches.Length() != 1) { + return false; + } + + dom::Touch* touch = touchEvent->mTouches.SafeElementAt(0); + if (!touch) { + return false; + } + aPoint = touch->mRefPoint; + } else { + aPoint = aEvent->mRefPoint; + } + return true; +} |