/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=2 sw=2 et 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 "gfxUtils.h" #include "mozilla/gfx/2D.h" #include "nsBoxLayoutState.h" #include "mozilla/dom/Touch.h" #include "mozilla/Move.h" #include "nsStyleContext.h" #include "nsPlaceholderFrame.h" #include "nsPresContext.h" #include "nsCOMPtr.h" #include "nsNameSpaceManager.h" #include "nsGkAtoms.h" #include "nsIContent.h" #include "nsHTMLParts.h" #include "nsViewManager.h" #include "nsView.h" #include "nsIPresShell.h" #include "nsCSSRendering.h" #include "nsIServiceManager.h" #include "nsBoxLayout.h" #include "nsSprocketLayout.h" #include "nsIScrollableFrame.h" #include "nsWidgetsCID.h" #include "nsCSSAnonBoxes.h" #include "nsContainerFrame.h" #include "nsIDOMElement.h" #include "nsITheme.h" #include "nsTransform2D.h" #include "mozilla/EventStateManager.h" #include "nsIDOMEvent.h" #include "nsDisplayList.h" #include "mozilla/Preferences.h" #include "nsThemeConstants.h" #include "nsLayoutUtils.h" #include "nsSliderFrame.h" #include <algorithm> // Needed for Print Preview #include "nsIURI.h" #include "mozilla/TouchEvents.h" using namespace mozilla; using namespace mozilla::dom; using namespace mozilla::gfx; //define DEBUG_REDRAW #define DEBUG_SPRING_SIZE 8 #define DEBUG_BORDER_SIZE 2 #define COIL_SIZE 8 //#define TEST_SANITY #ifdef DEBUG_rods //#define DO_NOISY_REFLOW #endif #ifdef DEBUG_LAYOUT bool nsBoxFrame::gDebug = false; nsIFrame* nsBoxFrame::mDebugChild = nullptr; #endif nsIFrame* NS_NewBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext, bool aIsRoot, nsBoxLayout* aLayoutManager) { return new (aPresShell) nsBoxFrame(aContext, aIsRoot, aLayoutManager); } nsIFrame* NS_NewBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext) { return new (aPresShell) nsBoxFrame(aContext); } NS_IMPL_FRAMEARENA_HELPERS(nsBoxFrame) #ifdef DEBUG NS_QUERYFRAME_HEAD(nsBoxFrame) NS_QUERYFRAME_ENTRY(nsBoxFrame) NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) #endif nsBoxFrame::nsBoxFrame(nsStyleContext* aContext, bool aIsRoot, nsBoxLayout* aLayoutManager) : nsContainerFrame(aContext) { mState |= NS_STATE_IS_HORIZONTAL; mState |= NS_STATE_AUTO_STRETCH; if (aIsRoot) mState |= NS_STATE_IS_ROOT; mValign = vAlign_Top; mHalign = hAlign_Left; // if no layout manager specified us the static sprocket layout nsCOMPtr<nsBoxLayout> layout = aLayoutManager; if (layout == nullptr) { NS_NewSprocketLayout(layout); } SetXULLayoutManager(layout); } nsBoxFrame::~nsBoxFrame() { } void nsBoxFrame::SetInitialChildList(ChildListID aListID, nsFrameList& aChildList) { nsContainerFrame::SetInitialChildList(aListID, aChildList); if (aListID == kPrincipalList) { // initialize our list of infos. nsBoxLayoutState state(PresContext()); CheckBoxOrder(); if (mLayoutManager) mLayoutManager->ChildrenSet(this, state, mFrames.FirstChild()); } } /* virtual */ void nsBoxFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext) { nsContainerFrame::DidSetStyleContext(aOldStyleContext); // 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 (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER) { AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT); } MarkIntrinsicISizesDirty(); CacheAttributes(); #ifdef DEBUG_LAYOUT // if we are root and this if (mState & NS_STATE_IS_ROOT) { GetDebugPref(); } #endif UpdateMouseThrough(); // register access key RegUnregAccessKey(true); } void nsBoxFrame::UpdateMouseThrough() { if (mContent) { static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::never, &nsGkAtoms::always, nullptr}; switch (mContent->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::mousethrough, strings, eCaseMatters)) { case 0: AddStateBits(NS_FRAME_MOUSE_THROUGH_NEVER); break; case 1: AddStateBits(NS_FRAME_MOUSE_THROUGH_ALWAYS); break; case 2: { RemoveStateBits(NS_FRAME_MOUSE_THROUGH_ALWAYS); RemoveStateBits(NS_FRAME_MOUSE_THROUGH_NEVER); break; } } } } void nsBoxFrame::CacheAttributes() { /* printf("Caching: "); XULDumpBox(stdout); printf("\n"); */ mValign = vAlign_Top; mHalign = hAlign_Left; bool orient = false; GetInitialOrientation(orient); if (orient) mState |= NS_STATE_IS_HORIZONTAL; else mState &= ~NS_STATE_IS_HORIZONTAL; bool normal = true; GetInitialDirection(normal); if (normal) mState |= NS_STATE_IS_DIRECTION_NORMAL; else mState &= ~NS_STATE_IS_DIRECTION_NORMAL; GetInitialVAlignment(mValign); GetInitialHAlignment(mHalign); bool equalSize = false; GetInitialEqualSize(equalSize); if (equalSize) mState |= NS_STATE_EQUAL_SIZE; else mState &= ~NS_STATE_EQUAL_SIZE; bool autostretch = !!(mState & NS_STATE_AUTO_STRETCH); GetInitialAutoStretch(autostretch); if (autostretch) mState |= NS_STATE_AUTO_STRETCH; else mState &= ~NS_STATE_AUTO_STRETCH; #ifdef DEBUG_LAYOUT bool debug = mState & NS_STATE_SET_TO_DEBUG; bool debugSet = GetInitialDebug(debug); if (debugSet) { mState |= NS_STATE_DEBUG_WAS_SET; if (debug) mState |= NS_STATE_SET_TO_DEBUG; else mState &= ~NS_STATE_SET_TO_DEBUG; } else { mState &= ~NS_STATE_DEBUG_WAS_SET; } #endif } #ifdef DEBUG_LAYOUT bool nsBoxFrame::GetInitialDebug(bool& aDebug) { if (!GetContent()) return false; static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::_false, &nsGkAtoms::_true, nullptr}; int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::debug, strings, eCaseMatters); if (index >= 0) { aDebug = index == 1; return true; } return false; } #endif bool nsBoxFrame::GetInitialHAlignment(nsBoxFrame::Halignment& aHalign) { if (!GetContent()) return false; // XXXdwh Everything inside this if statement is deprecated code. static nsIContent::AttrValuesArray alignStrings[] = {&nsGkAtoms::left, &nsGkAtoms::right, nullptr}; static const Halignment alignValues[] = {hAlign_Left, hAlign_Right}; int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::align, alignStrings, eCaseMatters); if (index >= 0) { aHalign = alignValues[index]; return true; } // Now that the deprecated stuff is out of the way, we move on to check the appropriate // attribute. For horizontal boxes, we are checking the PACK attribute. For vertical boxes // we are checking the ALIGN attribute. nsIAtom* attrName = IsXULHorizontal() ? nsGkAtoms::pack : nsGkAtoms::align; static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::_empty, &nsGkAtoms::start, &nsGkAtoms::center, &nsGkAtoms::end, nullptr}; static const Halignment values[] = {hAlign_Left/*not used*/, hAlign_Left, hAlign_Center, hAlign_Right}; index = GetContent()->FindAttrValueIn(kNameSpaceID_None, attrName, strings, eCaseMatters); if (index == nsIContent::ATTR_VALUE_NO_MATCH) { // The attr was present but had a nonsensical value. Revert to the default. return false; } if (index > 0) { aHalign = values[index]; return true; } // Now that we've checked for the attribute it's time to check CSS. 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; } } return false; } bool nsBoxFrame::GetInitialVAlignment(nsBoxFrame::Valignment& aValign) { if (!GetContent()) return false; static nsIContent::AttrValuesArray valignStrings[] = {&nsGkAtoms::top, &nsGkAtoms::baseline, &nsGkAtoms::middle, &nsGkAtoms::bottom, nullptr}; static const Valignment valignValues[] = {vAlign_Top, vAlign_BaseLine, vAlign_Middle, vAlign_Bottom}; int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::valign, valignStrings, eCaseMatters); if (index >= 0) { aValign = valignValues[index]; return true; } // Now that the deprecated stuff is out of the way, we move on to check the appropriate // attribute. For horizontal boxes, we are checking the ALIGN attribute. For vertical boxes // we are checking the PACK attribute. nsIAtom* attrName = IsXULHorizontal() ? nsGkAtoms::align : nsGkAtoms::pack; static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::_empty, &nsGkAtoms::start, &nsGkAtoms::center, &nsGkAtoms::baseline, &nsGkAtoms::end, nullptr}; static const Valignment values[] = {vAlign_Top/*not used*/, vAlign_Top, vAlign_Middle, vAlign_BaseLine, vAlign_Bottom}; index = GetContent()->FindAttrValueIn(kNameSpaceID_None, attrName, strings, eCaseMatters); if (index == nsIContent::ATTR_VALUE_NO_MATCH) { // The attr was present but had a nonsensical value. Revert to the default. return false; } if (index > 0) { aValign = values[index]; return true; } // Now that we've checked for the attribute it's time to check CSS. 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; } } return false; } void nsBoxFrame::GetInitialOrientation(bool& aIsHorizontal) { // see if we are a vertical or horizontal box. if (!GetContent()) return; // Check the style system first. const nsStyleXUL* boxInfo = StyleXUL(); if (boxInfo->mBoxOrient == StyleBoxOrient::Horizontal) { aIsHorizontal = true; } else { aIsHorizontal = false; } // Now see if we have an attribute. The attribute overrides // the style system value. static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::vertical, &nsGkAtoms::horizontal, nullptr}; int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::orient, strings, eCaseMatters); if (index >= 0) { aIsHorizontal = index == 1; } } 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. aIsNormal = (StyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR); // If text runs RTL then so do we. } 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. } // Now see if we have an attribute. The attribute overrides // the style system value. if (IsXULHorizontal()) { static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::reverse, &nsGkAtoms::ltr, &nsGkAtoms::rtl, nullptr}; int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::dir, strings, eCaseMatters); if (index >= 0) { bool values[] = {!aIsNormal, true, false}; aIsNormal = values[index]; } } else if (GetContent()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir, nsGkAtoms::reverse, eCaseMatters)) { aIsNormal = !aIsNormal; } } /* Returns true if it was set. */ bool nsBoxFrame::GetInitialEqualSize(bool& aEqualSize) { // see if we are a vertical or horizontal box. if (!GetContent()) return false; if (GetContent()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::equalsize, nsGkAtoms::always, eCaseMatters)) { aEqualSize = true; return true; } return false; } /* Returns true if it was set. */ bool nsBoxFrame::GetInitialAutoStretch(bool& aStretch) { if (!GetContent()) return false; // Check the align attribute. static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::_empty, &nsGkAtoms::stretch, nullptr}; int32_t index = GetContent()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::align, strings, eCaseMatters); if (index != nsIContent::ATTR_MISSING && index != 0) { aStretch = index == 1; return true; } // 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, nsDidReflowStatus aStatus) { nsFrameState preserveBits = mState & (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN); nsFrame::DidReflow(aPresContext, aReflowInput, aStatus); mState |= preserveBits; } bool nsBoxFrame::HonorPrintBackgroundSettings() { return (!mContent || !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(nsRenderingContext *aRenderingContext) { nscoord result; DISPLAY_MIN_WIDTH(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 state'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(nsRenderingContext *aRenderingContext) { nscoord result; DISPLAY_PREF_WIDTH(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 state'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); 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 aStatus = NS_FRAME_COMPLETE; // create the layout state nsBoxLayoutState state(aPresContext, aReflowInput.mRenderingContext, &aReflowInput, aReflowInput.mReflowDepth); WritingMode wm = aReflowInput.GetWritingMode(); LogicalSize computedSize(wm, aReflowInput.ComputedISize(), aReflowInput.ComputedBSize()); LogicalMargin m = aReflowInput.ComputedLogicalBorderPadding(); // GetXULBorderAndPadding(m); LogicalSize prefSize(wm); // if we are told to layout intrinsic then get our preferred size. NS_ASSERTION(computedSize.ISize(wm) != NS_INTRINSICSIZE, "computed inline size should always be computed"); if (computedSize.BSize(wm) == NS_INTRINSICSIZE) { nsSize physicalPrefSize = GetXULPrefSize(state); nsSize minSize = GetXULMinSize(state); nsSize maxSize = GetXULMaxSize(state); // XXXbz isn't GetXULPrefSize supposed to bounds-check for us? physicalPrefSize = BoundsCheck(minSize, physicalPrefSize, maxSize); prefSize = LogicalSize(wm, physicalPrefSize); } // get our desiredSize computedSize.ISize(wm) += m.IStart(wm) + m.IEnd(wm); if (aReflowInput.ComputedBSize() == NS_INTRINSICSIZE) { computedSize.BSize(wm) = prefSize.BSize(wm); // prefSize is border-box but min/max constraints are content-box. nscoord blockDirBorderPadding = aReflowInput.ComputedLogicalBorderPadding().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 (!(mState & NS_STATE_IS_ROOT)) { 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); NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize); } nsSize nsBoxFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) { NS_ASSERTION(aBoxLayoutState.GetRenderingContext(), "must have rendering context"); nsSize size(0,0); DISPLAY_PREF_SIZE(this, size); if (!DoesNeedRecalc(mPrefSize)) { return mPrefSize; } #ifdef DEBUG_LAYOUT PropagateDebug(aBoxLayoutState); #endif 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 = nsBox::GetXULPrefSize(aBoxLayoutState); } } nsSize minSize = GetXULMinSize(aBoxLayoutState); nsSize maxSize = GetXULMaxSize(aBoxLayoutState); mPrefSize = BoundsCheck(minSize, size, maxSize); return mPrefSize; } nscoord nsBoxFrame::GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) { if (!DoesNeedRecalc(mAscent)) return mAscent; #ifdef DEBUG_LAYOUT PropagateDebug(aBoxLayoutState); #endif if (IsXULCollapsed()) return 0; if (mLayoutManager) mAscent = mLayoutManager->GetAscent(this, aBoxLayoutState); else mAscent = nsBox::GetXULBoxAscent(aBoxLayoutState); 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 (!DoesNeedRecalc(mMinSize)) { return mMinSize; } #ifdef DEBUG_LAYOUT PropagateDebug(aBoxLayoutState); #endif if (IsXULCollapsed()) return size; // if the size was not completely redefined in CSS then ask our children bool widthSet, heightSet; if (!nsIFrame::AddXULMinSize(aBoxLayoutState, 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 = nsBox::GetXULMinSize(aBoxLayoutState); } } mMinSize = size; return size; } nsSize nsBoxFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) { NS_ASSERTION(aBoxLayoutState.GetRenderingContext(), "must have rendering context"); nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE); DISPLAY_MAX_SIZE(this, size); if (!DoesNeedRecalc(mMaxSize)) { return mMaxSize; } #ifdef DEBUG_LAYOUT PropagateDebug(aBoxLayoutState); #endif 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 = nsBox::GetXULMaxSize(aBoxLayoutState); } } mMaxSize = size; return size; } nscoord nsBoxFrame::GetXULFlex() { if (!DoesNeedRecalc(mFlex)) return mFlex; mFlex = nsBox::GetXULFlex(); return mFlex; } /** * If subclassing please subclass this method not layout. * layout will call this method. */ NS_IMETHODIMP nsBoxFrame::DoXULLayout(nsBoxLayoutState& aState) { uint32_t oldFlags = aState.LayoutFlags(); aState.SetLayoutFlags(0); nsresult rv = NS_OK; if (mLayoutManager) { CoordNeedsRecalc(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 (!(mState & NS_STATE_IS_ROOT)) { 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 = NS_FRAME_COMPLETE; ReflowAbsoluteFrames(aState.PresContext(), desiredSize, reflowInput, reflowStatus); RemoveStateBits(NS_FRAME_IN_REFLOW); } return rv; } void nsBoxFrame::DestroyFrom(nsIFrame* aDestructRoot) { // unregister access key RegUnregAccessKey(false); // clean up the container box's layout manager and child boxes SetXULLayoutManager(nullptr); nsContainerFrame::DestroyFrom(aDestructRoot); } #ifdef DEBUG_LAYOUT nsresult nsBoxFrame::SetXULDebug(nsBoxLayoutState& aState, bool aDebug) { // see if our state matches the given debug state bool debugSet = mState & NS_STATE_CURRENTLY_IN_DEBUG; bool debugChanged = (!aDebug && debugSet) || (aDebug && !debugSet); // if it doesn't then tell each child below us the new debug state if (debugChanged) { if (aDebug) { mState |= NS_STATE_CURRENTLY_IN_DEBUG; } else { mState &= ~NS_STATE_CURRENTLY_IN_DEBUG; } SetDebugOnChildList(aState, mFirstChild, aDebug); MarkIntrinsicISizesDirty(); } return NS_OK; } #endif /* virtual */ void nsBoxFrame::MarkIntrinsicISizesDirty() { SizeNeedsRecalc(mPrefSize); SizeNeedsRecalc(mMinSize); SizeNeedsRecalc(mMaxSize); CoordNeedsRecalc(mFlex); CoordNeedsRecalc(mAscent); if (mLayoutManager) { nsBoxLayoutState state(PresContext()); mLayoutManager->IntrinsicISizesDirty(this, state); } // Don't call base class method, since everything it does is within an // IsXULBoxWrapped check. } void nsBoxFrame::RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) { NS_PRECONDITION(aListID == kPrincipalList, "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 PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } void nsBoxFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame, 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"); NS_PRECONDITION(aListID == kPrincipalList, "We don't support out-of-flow kids"); nsBoxLayoutState state(PresContext()); // insert the child frames const nsFrameList::Slice& newFrames = mFrames.InsertFrames(this, aPrevFrame, aFrameList); // notify the layout manager if (mLayoutManager) mLayoutManager->ChildrenInserted(this, state, aPrevFrame, newFrames); // Make sure to check box order _after_ notifying the layout // manager; otherwise the slice we give the layout manager will // just be bogus. If the layout manager cares about the order, we // just lose. CheckBoxOrder(); #ifdef DEBUG_LAYOUT // if we are in debug make sure our children are in debug as well. if (mState & NS_STATE_CURRENTLY_IN_DEBUG) SetDebugOnChildList(state, mFrames.FirstChild(), true); #endif PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } void nsBoxFrame::AppendFrames(ChildListID aListID, nsFrameList& aFrameList) { NS_PRECONDITION(aListID == kPrincipalList, "We don't support out-of-flow kids"); nsBoxLayoutState state(PresContext()); // append the new frames const nsFrameList::Slice& newFrames = mFrames.AppendFrames(this, aFrameList); // notify the layout manager if (mLayoutManager) mLayoutManager->ChildrenAppended(this, state, newFrames); // Make sure to check box order _after_ notifying the layout // manager; otherwise the slice we give the layout manager will // just be bogus. If the layout manager cares about the order, we // just lose. CheckBoxOrder(); #ifdef DEBUG_LAYOUT // if we are in debug make sure our children are in debug as well. if (mState & NS_STATE_CURRENTLY_IN_DEBUG) SetDebugOnChildList(state, mFrames.FirstChild(), true); #endif // XXXbz why is this NS_FRAME_FIRST_REFLOW check here? if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) { PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } } /* virtual */ nsContainerFrame* nsBoxFrame::GetContentInsertionFrame() { if (GetStateBits() & NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK) return PrincipalChildList().FirstChild()->GetContentInsertionFrame(); return nsContainerFrame::GetContentInsertionFrame(); } nsresult nsBoxFrame::AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) { nsresult rv = nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); // Ignore 'width', 'height', 'screenX', 'screenY' and 'sizemode' on a // <window>. if (mContent->IsAnyOfXULElements(nsGkAtoms::window, nsGkAtoms::page, nsGkAtoms::dialog, nsGkAtoms::wizard) && (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::left || aAttribute == nsGkAtoms::top || aAttribute == nsGkAtoms::right || aAttribute == nsGkAtoms::bottom || aAttribute == nsGkAtoms::start || aAttribute == nsGkAtoms::end || aAttribute == nsGkAtoms::minwidth || aAttribute == nsGkAtoms::maxwidth || aAttribute == nsGkAtoms::minheight || aAttribute == nsGkAtoms::maxheight || aAttribute == nsGkAtoms::flex || aAttribute == nsGkAtoms::orient || aAttribute == nsGkAtoms::pack || aAttribute == nsGkAtoms::dir || aAttribute == nsGkAtoms::mousethrough || aAttribute == nsGkAtoms::equalsize) { if (aAttribute == nsGkAtoms::align || aAttribute == nsGkAtoms::valign || aAttribute == nsGkAtoms::orient || aAttribute == nsGkAtoms::pack || #ifdef DEBUG_LAYOUT aAttribute == nsGkAtoms::debug || #endif aAttribute == nsGkAtoms::dir) { mValign = nsBoxFrame::vAlign_Top; mHalign = nsBoxFrame::hAlign_Left; bool orient = true; GetInitialOrientation(orient); if (orient) mState |= NS_STATE_IS_HORIZONTAL; else mState &= ~NS_STATE_IS_HORIZONTAL; bool normal = true; GetInitialDirection(normal); if (normal) mState |= NS_STATE_IS_DIRECTION_NORMAL; else mState &= ~NS_STATE_IS_DIRECTION_NORMAL; GetInitialVAlignment(mValign); GetInitialHAlignment(mHalign); bool equalSize = false; GetInitialEqualSize(equalSize); if (equalSize) mState |= NS_STATE_EQUAL_SIZE; else mState &= ~NS_STATE_EQUAL_SIZE; #ifdef DEBUG_LAYOUT bool debug = mState & NS_STATE_SET_TO_DEBUG; bool debugSet = GetInitialDebug(debug); if (debugSet) { mState |= NS_STATE_DEBUG_WAS_SET; if (debug) mState |= NS_STATE_SET_TO_DEBUG; else mState &= ~NS_STATE_SET_TO_DEBUG; } else { mState &= ~NS_STATE_DEBUG_WAS_SET; } #endif bool autostretch = !!(mState & NS_STATE_AUTO_STRETCH); GetInitialAutoStretch(autostretch); if (autostretch) mState |= NS_STATE_AUTO_STRETCH; else mState &= ~NS_STATE_AUTO_STRETCH; } else if (aAttribute == nsGkAtoms::left || aAttribute == nsGkAtoms::top || aAttribute == nsGkAtoms::right || aAttribute == nsGkAtoms::bottom || aAttribute == nsGkAtoms::start || aAttribute == nsGkAtoms::end) { mState &= ~NS_STATE_STACK_NOT_POSITIONED; } else if (aAttribute == nsGkAtoms::mousethrough) { UpdateMouseThrough(); } PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); } else if (aAttribute == nsGkAtoms::ordinal) { nsIFrame* parent = GetParentXULBox(this); // If our parent is not a box, there's not much we can do... but in that // case our ordinal doesn't matter anyway, so that's ok. // Also don't bother with popup frames since they are kept on the // kPopupList and XULRelayoutChildAtOrdinal() only handles // principal children. if (parent && !(GetStateBits() & NS_FRAME_OUT_OF_FLOW) && StyleDisplay()->mDisplay != mozilla::StyleDisplay::Popup) { parent->XULRelayoutChildAtOrdinal(this); // XXXldb Should this instead be a tree change on the child or parent? PresContext()->PresShell()-> FrameNeedsReflow(parent, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); } } // If the accesskey changed, register for the new value // The old value has been unregistered in nsXULElement::SetAttr else if (aAttribute == nsGkAtoms::accesskey) { RegUnregAccessKey(true); } 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). PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); } return rv; } #ifdef DEBUG_LAYOUT void nsBoxFrame::GetDebugPref() { gDebug = Preferences::GetBool("xul.debug.box"); } class nsDisplayXULDebug : public nsDisplayItem { public: nsDisplayXULDebug(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) : nsDisplayItem(aBuilder, aFrame) { MOZ_COUNT_CTOR(nsDisplayXULDebug); } #ifdef NS_BUILD_REFCNT_LOGGING virtual ~nsDisplayXULDebug() { MOZ_COUNT_DTOR(nsDisplayXULDebug); } #endif virtual void HitTest(nsDisplayListBuilder* aBuilder, nsRect aRect, HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames) { nsPoint rectCenter(aRect.x + aRect.width / 2, aRect.y + aRect.height / 2); static_cast<nsBoxFrame*>(mFrame)-> DisplayDebugInfoFor(this, rectCenter - ToReferenceFrame()); aOutFrames->AppendElement(this); } virtual void Paint(nsDisplayListBuilder* aBuilder nsRenderingContext* aCtx); NS_DISPLAY_DECL_NAME("XULDebug", TYPE_XUL_DEBUG) }; void nsDisplayXULDebug::Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) { static_cast<nsBoxFrame*>(mFrame)-> PaintXULDebugOverlay(*aCtx->GetDrawTarget(), ToReferenceFrame()); } static void PaintXULDebugBackground(nsIFrame* aFrame, DrawTarget* aDrawTarget, const nsRect& aDirtyRect, nsPoint aPt) { static_cast<nsBoxFrame*>(aFrame)->PaintXULDebugBackground(aDrawTarget, aPt); } #endif void nsBoxFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) { bool forceLayer = false; if (GetContent()->IsXULElement()) { // forcelayer is only supported on XUL elements with box layout if (GetContent()->HasAttr(kNameSpaceID_None, nsGkAtoms::layer)) { forceLayer = true; } // Check for frames that are marked as a part of the region used // in calculating glass margins on Windows. const nsStyleDisplay* styles = StyleDisplay(); if (styles && styles->mAppearance == NS_THEME_WIN_EXCLUDE_GLASS) { aBuilder->AddWindowExcludeGlassRegion( nsRect(aBuilder->ToReferenceFrame(this), GetSize())); } } nsDisplayListCollection tempLists; const nsDisplayListSet& destination = forceLayer ? tempLists : aLists; DisplayBorderBackgroundOutline(aBuilder, destination); #ifdef DEBUG_LAYOUT if (mState & NS_STATE_CURRENTLY_IN_DEBUG) { destination.BorderBackground()->AppendNewToTop(new (aBuilder) nsDisplayGeneric(aBuilder, this, PaintXULDebugBackground, "XULDebugBackground")); destination.Outlines()->AppendNewToTop(new (aBuilder) nsDisplayXULDebug(aBuilder, this)); } #endif BuildDisplayListForChildren(aBuilder, aDirtyRect, destination); // see if we have to draw a selection frame around this container DisplaySelectionOverlay(aBuilder, destination.Content()); if (forceLayer) { // This is a bit of a hack. Collect up all descendant display items // and merge them into a single Content() list. This can cause us // to violate CSS stacking order, but forceLayer is a magic // XUL-only extension anyway. nsDisplayList masterList; masterList.AppendToTop(tempLists.BorderBackground()); masterList.AppendToTop(tempLists.BlockBorderBackgrounds()); masterList.AppendToTop(tempLists.Floats()); masterList.AppendToTop(tempLists.Content()); masterList.AppendToTop(tempLists.PositionedDescendants()); masterList.AppendToTop(tempLists.Outlines()); // Wrap the list to make it its own layer aLists.Content()->AppendNewToTop(new (aBuilder) nsDisplayOwnLayer(aBuilder, this, &masterList)); } } void nsBoxFrame::BuildDisplayListForChildren(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) { nsIFrame* kid = mFrames.FirstChild(); // Put each child's background onto the BlockBorderBackgrounds list // to emulate the existing two-layer XUL painting scheme. nsDisplayListSet set(aLists, aLists.BlockBorderBackgrounds()); // The children should be in the right order while (kid) { BuildDisplayListForChild(aBuilder, kid, aDirtyRect, set); kid = kid->GetNextSibling(); } } // REVIEW: PaintChildren did a few things none of which are a big deal // anymore: // * Paint some debugging rects for this frame. // This is done by nsDisplayXULDebugBackground, which goes in the // BorderBackground() layer so it isn't clipped by OVERFLOW_CLIP. // * Apply OVERFLOW_CLIP to the children. // This is now in nsFrame::BuildDisplayListForStackingContext/Child. // * Actually paint the children. // Moved to BuildDisplayList. // * Paint per-kid debug information. // This is done by nsDisplayXULDebug, which is in the Outlines() // layer so it goes on top. This means it is not clipped by OVERFLOW_CLIP, // whereas it did used to respect OVERFLOW_CLIP, but too bad. #ifdef DEBUG_LAYOUT void nsBoxFrame::PaintXULDebugBackground(DrawTarget* aDrawTarget, nsPoint aPt) { nsMargin border; GetXULBorder(border); nsMargin debugBorder; nsMargin debugMargin; nsMargin debugPadding; bool isHorizontal = IsXULHorizontal(); GetDebugBorder(debugBorder); PixelMarginToTwips(debugBorder); GetDebugMargin(debugMargin); PixelMarginToTwips(debugMargin); GetDebugPadding(debugPadding); PixelMarginToTwips(debugPadding); nsRect inner(mRect); inner.MoveTo(aPt); inner.Deflate(debugMargin); inner.Deflate(border); //nsRect borderRect(inner); int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel(); ColorPattern color(ToDeviceColor(isHorizontal ? Color(0.f, 0.f, 1.f, 1.f) : Color(1.f, 0.f, 0.f, 1.f))); //left nsRect r(inner); r.width = debugBorder.left; aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color); // top r = inner; r.height = debugBorder.top; aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color); //right r = inner; r.x = r.x + r.width - debugBorder.right; r.width = debugBorder.right; aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color); //bottom r = inner; r.y = r.y + r.height - debugBorder.bottom; r.height = debugBorder.bottom; aDrawTarget->FillRect(NSRectToRect(r, appUnitsPerDevPixel), color); // If we have dirty children or we are dirty place a green border around us. if (NS_SUBTREE_DIRTY(this)) { nsRect dirty(inner); ColorPattern green(ToDeviceColor(Color(0.f, 1.f, 0.f, 1.f))); aDrawTarget->StrokeRect(NSRectToRect(dirty, appUnitsPerDevPixel), green); } } void nsBoxFrame::PaintXULDebugOverlay(DrawTarget& aDrawTarget, nsPoint aPt) { nsMargin border; GetXULBorder(border); nsMargin debugMargin; GetDebugMargin(debugMargin); PixelMarginToTwips(debugMargin); nsRect inner(mRect); inner.MoveTo(aPt); inner.Deflate(debugMargin); inner.Deflate(border); nscoord onePixel = GetPresContext()->IntScaledPixelsToTwips(1); kid = nsBox::GetChildXULBox(this); while (nullptr != kid) { bool isHorizontal = IsXULHorizontal(); nscoord x, y, borderSize, spacerSize; nsRect cr(kid->mRect); nsMargin margin; kid->GetXULMargin(margin); cr.Inflate(margin); if (isHorizontal) { cr.y = inner.y; x = cr.x; y = cr.y + onePixel; spacerSize = debugBorder.top - onePixel*4; } else { cr.x = inner.x; x = cr.y; y = cr.x + onePixel; spacerSize = debugBorder.left - onePixel*4; } nscoord flex = kid->GetXULFlex(); if (!kid->IsXULCollapsed()) { if (isHorizontal) borderSize = cr.width; else borderSize = cr.height; DrawSpacer(GetPresContext(), aDrawTarget, isHorizontal, flex, x, y, borderSize, spacerSize); } kid = GetNextXULBox(kid); } } #endif #ifdef DEBUG_LAYOUT void nsBoxFrame::GetBoxName(nsAutoString& aName) { GetFrameName(aName); } #endif #ifdef DEBUG_FRAME_DUMP nsresult nsBoxFrame::GetFrameName(nsAString& aResult) const { return MakeFrameName(NS_LITERAL_STRING("Box"), aResult); } #endif nsIAtom* nsBoxFrame::GetType() const { return nsGkAtoms::boxFrame; } #ifdef DEBUG_LAYOUT nsresult nsBoxFrame::GetXULDebug(bool& aDebug) { aDebug = (mState & NS_STATE_CURRENTLY_IN_DEBUG); return NS_OK; } #endif // REVIEW: nsBoxFrame::GetFrameForPoint is a problem because of 'mousethrough' // attribute support. Here's how it works: // * For each child frame F, we determine the target frame T(F) by recursively // invoking GetFrameForPoint on the child // * Let F' be the last child frame such that T(F') doesn't have mousethrough. // If F' exists, return T(F') // * Otherwise let F'' be the first child frame such that T(F'') is non-null. // If F'' exists, return T(F'') // * Otherwise return this frame, if this frame contains the point // * Otherwise return null // It's not clear how this should work for more complex z-ordering situations. // The basic principle seems to be that if a frame F has a descendant // 'mousethrough' frame that includes the target position, then F // will not receive events (unless it overrides GetFrameForPoint). // A 'mousethrough' frame will only receive an event if, after applying that rule, // all eligible frames are 'mousethrough'; the bottom-most inner-most 'mousethrough' // frame is then chosen (the first eligible frame reached in a // traversal of the frame tree --- pre/post is irrelevant since ancestors // of the mousethrough frames can't be eligible). // IMHO this is very bogus and adds a great deal of complexity for something // that is very rarely used. So I'm redefining 'mousethrough' to the following: // a frame with mousethrough is transparent to mouse events. This is compatible // with the way 'mousethrough' is used in Seamonkey's navigator.xul and // Firefox's browser.xul. The only other place it's used is in the 'expander' // XBL binding, which in our tree is only used by Thunderbird SMIME Advanced // Preferences, and I can't figure out what that does, so I'll have to test it. // If it's broken I'll probably just change the binding to use it more sensibly. // This new behaviour is implemented in nsDisplayList::HitTest. // REVIEW: This debug-box stuff is annoying. I'm just going to put debug boxes // in the outline layer and avoid GetDebugBoxAt. // REVIEW: GetCursor had debug-only event dumping code. I have replaced it // with instrumentation in nsDisplayXULDebug. #ifdef DEBUG_LAYOUT void nsBoxFrame::DrawLine(DrawTarget& aDrawTarget, bool aHorizontal, nscoord x1, nscoord y1, nscoord x2, nscoord y2) { nsPoint p1(x1, y1); nsPoint p2(x2, y2); if (!aHorizontal) { Swap(p1.x, p1.y); Swap(p2.x, p2.y); } ColorPattern white(ToDeviceColor(Color(1.f, 1.f, 1.f, 1.f))); StrokeLineWithSnapping(p1, p2, PresContext()->AppUnitsPerDevPixel(), aDrawTarget, color); } void nsBoxFrame::FillRect(DrawTarget& aDrawTarget, bool aHorizontal, nscoord x, nscoord y, nscoord width, nscoord height) { Rect rect = NSRectToSnappedRect(aHorizontal ? nsRect(x, y, width, height) : nsRect(y, x, height, width), PresContext()->AppUnitsPerDevPixel(), aDrawTarget); ColorPattern white(ToDeviceColor(Color(1.f, 1.f, 1.f, 1.f))); aDrawTarget.FillRect(rect, white); } void nsBoxFrame::DrawSpacer(nsPresContext* aPresContext, DrawTarget& aDrawTarget, bool aHorizontal, int32_t flex, nscoord x, nscoord y, nscoord size, nscoord spacerSize) { nscoord onePixel = aPresContext->IntScaledPixelsToTwips(1); // if we do draw the coils int distance = 0; int center = 0; int offset = 0; int coilSize = COIL_SIZE*onePixel; int halfSpacer = spacerSize/2; distance = size; center = y + halfSpacer; offset = x; int coils = distance/coilSize; int halfCoilSize = coilSize/2; if (flex == 0) { DrawLine(aDrawTarget, aHorizontal, x,y + spacerSize/2, x + size, y + spacerSize/2); } else { for (int i=0; i < coils; i++) { DrawLine(aDrawTarget, aHorizontal, offset, center+halfSpacer, offset+halfCoilSize, center-halfSpacer); DrawLine(aDrawTarget, aHorizontal, offset+halfCoilSize, center-halfSpacer, offset+coilSize, center+halfSpacer); offset += coilSize; } } FillRect(aDrawTarget, aHorizontal, x + size - spacerSize/2, y, spacerSize/2, spacerSize); FillRect(aDrawTarget, aHorizontal, x, y, spacerSize/2, spacerSize); } void nsBoxFrame::GetDebugBorder(nsMargin& aInset) { aInset.SizeTo(2,2,2,2); if (IsXULHorizontal()) aInset.top = 10; else aInset.left = 10; } void nsBoxFrame::GetDebugMargin(nsMargin& aInset) { aInset.SizeTo(2,2,2,2); } void nsBoxFrame::GetDebugPadding(nsMargin& aPadding) { aPadding.SizeTo(2,2,2,2); } void nsBoxFrame::PixelMarginToTwips(nsMargin& aMarginPixels) { nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1); aMarginPixels.left *= onePixel; aMarginPixels.right *= onePixel; aMarginPixels.top *= onePixel; aMarginPixels.bottom *= onePixel; } void nsBoxFrame::GetValue(nsPresContext* aPresContext, const nsSize& a, const nsSize& b, char* ch) { float p2t = aPresContext->ScaledPixelsToTwips(); char width[100]; char height[100]; if (a.width == NS_INTRINSICSIZE) sprintf(width,"%s","INF"); else sprintf(width,"%d", nscoord(a.width/*/p2t*/)); if (a.height == NS_INTRINSICSIZE) sprintf(height,"%s","INF"); else sprintf(height,"%d", nscoord(a.height/*/p2t*/)); sprintf(ch, "(%s%s, %s%s)", width, (b.width != NS_INTRINSICSIZE ? "[SET]" : ""), height, (b.height != NS_INTRINSICSIZE ? "[SET]" : "")); } void nsBoxFrame::GetValue(nsPresContext* aPresContext, int32_t a, int32_t b, char* ch) { if (a == NS_INTRINSICSIZE) sprintf(ch, "%d[SET]", b); else sprintf(ch, "%d", a); } nsresult nsBoxFrame::DisplayDebugInfoFor(nsIFrame* aBox, nsPoint& aPoint) { nsBoxLayoutState state(GetPresContext()); nscoord x = aPoint.x; nscoord y = aPoint.y; // get the area inside our border but not our debug margins. nsRect insideBorder(aBox->mRect); insideBorder.MoveTo(0,0): nsMargin border(0,0,0,0); aBox->GetXULBorderAndPadding(border); insideBorder.Deflate(border); bool isHorizontal = IsXULHorizontal(); if (!insideBorder.Contains(nsPoint(x,y))) return NS_ERROR_FAILURE; //printf("%%%%%% inside box %%%%%%%\n"); int count = 0; nsIFrame* child = nsBox::GetChildXULBox(aBox); nsMargin m; nsMargin m2; GetDebugBorder(m); PixelMarginToTwips(m); GetDebugMargin(m2); PixelMarginToTwips(m2); m += m2; if ((isHorizontal && y < insideBorder.y + m.top) || (!isHorizontal && x < insideBorder.x + m.left)) { //printf("**** inside debug border *******\n"); while (child) { const nsRect& r = child->mRect; // if we are not in the child. But in the spacer above the child. if ((isHorizontal && x >= r.x && x < r.x + r.width) || (!isHorizontal && y >= r.y && y < r.y + r.height)) { aCursor = NS_STYLE_CURSOR_POINTER; // found it but we already showed it. if (mDebugChild == child) return NS_OK; if (aBox->GetContent()) { printf("---------------\n"); XULDumpBox(stdout); printf("\n"); } if (child->GetContent()) { printf("child #%d: ", count); child->XULDumpBox(stdout); printf("\n"); } mDebugChild = child; nsSize prefSizeCSS(NS_INTRINSICSIZE, NS_INTRINSICSIZE); nsSize minSizeCSS (NS_INTRINSICSIZE, NS_INTRINSICSIZE); nsSize maxSizeCSS (NS_INTRINSICSIZE, NS_INTRINSICSIZE); nscoord flexCSS = NS_INTRINSICSIZE; bool widthSet, heightSet; nsIFrame::AddXULPrefSize(child, prefSizeCSS, widthSet, heightSet); nsIFrame::AddXULMinSize (state, child, minSizeCSS, widthSet, heightSet); nsIFrame::AddXULMaxSize (child, maxSizeCSS, widthSet, heightSet); nsIFrame::AddXULFlex (child, flexCSS); nsSize prefSize = child->GetXULPrefSize(state); nsSize minSize = child->GetXULMinSize(state); nsSize maxSize = child->GetXULMaxSize(state); nscoord flexSize = child->GetXULFlex(); nscoord ascentSize = child->GetXULBoxAscent(state); char min[100]; char pref[100]; char max[100]; char calc[100]; char flex[100]; char ascent[100]; nsSize actualSize; GetFrameSizeWithMargin(child, actualSize); nsSize actualSizeCSS (NS_INTRINSICSIZE, NS_INTRINSICSIZE); GetValue(aPresContext, minSize, minSizeCSS, min); GetValue(aPresContext, prefSize, prefSizeCSS, pref); GetValue(aPresContext, maxSize, maxSizeCSS, max); GetValue(aPresContext, actualSize, actualSizeCSS, calc); GetValue(aPresContext, flexSize, flexCSS, flex); GetValue(aPresContext, ascentSize, NS_INTRINSICSIZE, ascent); printf("min%s, pref%s, max%s, actual%s, flex=%s, ascent=%s\n\n", min, pref, max, calc, flex, ascent ); return NS_OK; } child = GetNextXULBox(child); count++; } } else { } mDebugChild = nullptr; return NS_OK; } void nsBoxFrame::SetDebugOnChildList(nsBoxLayoutState& aState, nsIFrame* aChild, bool aDebug) { nsIFrame* child = nsBox::GetChildXULBox(this); while (child) { child->SetXULDebug(aState, aDebug); child = GetNextXULBox(child); } } nsresult nsBoxFrame::GetFrameSizeWithMargin(nsIFrame* aBox, nsSize& aSize) { nsRect rect(aBox->GetRect()); nsMargin margin(0,0,0,0); aBox->GetXULMargin(margin); rect.Inflate(margin); aSize.width = rect.width; aSize.height = rect.height; return NS_OK; } #endif // If you make changes to this function, check its counterparts // in nsTextBoxFrame and nsXULLabelFrame void nsBoxFrame::RegUnregAccessKey(bool aDoReg) { MOZ_ASSERT(mContent); // only support accesskeys for the following elements if (!mContent->IsAnyOfXULElements(nsGkAtoms::button, nsGkAtoms::toolbarbutton, nsGkAtoms::checkbox, nsGkAtoms::textbox, nsGkAtoms::tab, nsGkAtoms::radio)) { return; } nsAutoString accessKey; mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey); if (accessKey.IsEmpty()) return; // With a valid PresContext we can get the ESM // and register the access key EventStateManager* esm = PresContext()->EventStateManager(); uint32_t key = accessKey.First(); if (aDoReg) esm->RegisterAccessKey(mContent, key); else esm->UnregisterAccessKey(mContent, key); } bool nsBoxFrame::SupportsOrdinalsInChildren() { return true; } // Helper less-than-or-equal function, used in CheckBoxOrder() as a // template-parameter for the sorting functions. bool IsBoxOrdinalLEQ(nsIFrame* aFrame1, nsIFrame* aFrame2) { // If we've got a placeholder frame, use its out-of-flow frame's ordinal val. nsIFrame* aRealFrame1 = nsPlaceholderFrame::GetRealFrameFor(aFrame1); nsIFrame* aRealFrame2 = nsPlaceholderFrame::GetRealFrameFor(aFrame2); return aRealFrame1->GetXULOrdinal() <= aRealFrame2->GetXULOrdinal(); } void nsBoxFrame::CheckBoxOrder() { if (SupportsOrdinalsInChildren() && !nsIFrame::IsFrameListSorted<IsBoxOrdinalLEQ>(mFrames)) { nsIFrame::SortFrameList<IsBoxOrdinalLEQ>(mFrames); } } nsresult nsBoxFrame::LayoutChildAt(nsBoxLayoutState& aState, nsIFrame* aBox, const nsRect& aRect) { // get the current rect nsRect oldRect(aBox->GetRect()); aBox->SetXULBounds(aState, aRect); bool layout = NS_SUBTREE_DIRTY(aBox); if (layout || (oldRect.width != aRect.width || oldRect.height != aRect.height)) { return aBox->XULLayout(aState); } return NS_OK; } nsresult nsBoxFrame::XULRelayoutChildAtOrdinal(nsIFrame* aChild) { if (!SupportsOrdinalsInChildren()) return NS_OK; uint32_t ord = aChild->GetXULOrdinal(); nsIFrame* child = mFrames.FirstChild(); nsIFrame* newPrevSib = nullptr; while (child) { if (ord < child->GetXULOrdinal()) { break; } if (child != aChild) { newPrevSib = child; } child = GetNextXULBox(child); } if (aChild->GetPrevSibling() == newPrevSib) { // This box is not moving. return NS_OK; } // Take |aChild| out of its old position in the child list. mFrames.RemoveFrame(aChild); // Insert it after |newPrevSib| or at the start if it's null. mFrames.InsertFrame(nullptr, newPrevSib, aChild); return NS_OK; } /** * 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 : 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; } 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->AttrValueIs(kNameSpaceID_None, nsGkAtoms::allowevents, nsGkAtoms::_true, eCaseMatters)) { // 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); } } } class nsXULEventRedirectorWrapper : public nsDisplayWrapper { public: explicit nsXULEventRedirectorWrapper(nsIFrame* aTargetFrame) : mTargetFrame(aTargetFrame) {} virtual nsDisplayItem* WrapList(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, nsDisplayList* aList) override { return new (aBuilder) nsDisplayXULEventRedirector(aBuilder, aFrame, aList, mTargetFrame); } virtual nsDisplayItem* WrapItem(nsDisplayListBuilder* aBuilder, nsDisplayItem* aItem) override { return new (aBuilder) 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, 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; }