The Tor Browser / file revision

 /* -*- 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 "nsBoxLayoutState.h"

 #include "nsBoxFrame.h"

 #include "mozilla/dom/Touch.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 <algorithm>

 // Needed for Print Preview

 #include "nsIURI.h"

 #include "mozilla/TouchEvents.h"

 using namespace mozilla;

 using namespace mozilla::dom;

 //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(aPresShell, aContext, aIsRoot, aLayoutManager);

 }

 nsIFrame*

 NS_NewBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)

 {

   return new (aPresShell) nsBoxFrame(aPresShell, aContext);

 }

 NS_IMPL_FRAMEARENA_HELPERS(nsBoxFrame)

 #ifdef DEBUG

 NS_QUERYFRAME_HEAD(nsBoxFrame)

   NS_QUERYFRAME_ENTRY(nsBoxFrame)

 NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)

 #endif

 nsBoxFrame::nsBoxFrame(nsIPresShell* aPresShell,

                        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(aPresShell, layout);

   }

   SetLayoutManager(layout);

 }

 nsBoxFrame::~nsBoxFrame()

 {

 }

 nsresult

 nsBoxFrame::SetInitialChildList(ChildListID     aListID,

                                 nsFrameList&    aChildList)

 {

   nsresult r = nsContainerFrame::SetInitialChildList(aListID, aChildList);

   if (r == NS_OK) {

     // initialize our list of infos.

     nsBoxLayoutState state(PresContext());

     CheckBoxOrder();

     if (mLayoutManager)

       mLayoutManager->ChildrenSet(this, state, mFrames.FirstChild());

   } else {

     NS_WARNING("Warning add child failed!!\n");

   }

   return r;

 }

 /* 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,

                  nsIFrame*        aParent,

                  nsIFrame*        aPrevInFlow)

 {

   nsContainerFrame::Init(aContent, aParent, aPrevInFlow);

   if (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER) {

     AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);

   }

   MarkIntrinsicWidthsDirty();

   CacheAttributes();

 #ifdef DEBUG_LAYOUT

     // if we are root and this

   if (mState & NS_STATE_IS_ROOT) 

       GetDebugPref(GetPresContext());

 #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: ");

   DumpBox(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 = IsHorizontal() ? 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 (IsHorizontal()) {

     switch (boxInfo->mBoxPack) {

       case NS_STYLE_BOX_PACK_START:

         aHalign = nsBoxFrame::hAlign_Left;

         return true;

       case NS_STYLE_BOX_PACK_CENTER:

         aHalign = nsBoxFrame::hAlign_Center;

         return true;

       case NS_STYLE_BOX_PACK_END:

         aHalign = nsBoxFrame::hAlign_Right;

         return true;

       default: // Nonsensical value. Just bail.

         return false;

     }

   }

   else {

     switch (boxInfo->mBoxAlign) {

       case NS_STYLE_BOX_ALIGN_START:

         aHalign = nsBoxFrame::hAlign_Left;

         return true;

       case NS_STYLE_BOX_ALIGN_CENTER:

         aHalign = nsBoxFrame::hAlign_Center;

         return true;

       case NS_STYLE_BOX_ALIGN_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 = IsHorizontal() ? 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 (IsHorizontal()) {

     switch (boxInfo->mBoxAlign) {

       case NS_STYLE_BOX_ALIGN_START:

         aValign = nsBoxFrame::vAlign_Top;

         return true;

       case NS_STYLE_BOX_ALIGN_CENTER:

         aValign = nsBoxFrame::vAlign_Middle;

         return true;

       case NS_STYLE_BOX_ALIGN_BASELINE:

         aValign = nsBoxFrame::vAlign_BaseLine;

         return true;

       case NS_STYLE_BOX_ALIGN_END:

         aValign = nsBoxFrame::vAlign_Bottom;

         return true;

       default: // Nonsensical value. Just bail.

         return false;

     }

   }

   else {

     switch (boxInfo->mBoxPack) {

       case NS_STYLE_BOX_PACK_START:

         aValign = nsBoxFrame::vAlign_Top;

         return true;

       case NS_STYLE_BOX_PACK_CENTER:

         aValign = nsBoxFrame::vAlign_Middle;

         return true;

       case NS_STYLE_BOX_PACK_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 == NS_STYLE_BOX_ORIENT_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 (IsHorizontal()) {

     // 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 == NS_STYLE_BOX_DIRECTION_REVERSE)

     aIsNormal = !aIsNormal; // Invert our direction.

   // Now see if we have an attribute.  The attribute overrides

   // the style system value.

   if (IsHorizontal()) {

     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 == NS_STYLE_BOX_ALIGN_STRETCH);

   return true;

 }

 nsresult

 nsBoxFrame::DidReflow(nsPresContext*           aPresContext,

                       const nsHTMLReflowState*  aReflowState,

                       nsDidReflowStatus         aStatus)

 {

   nsFrameState preserveBits =

     mState & (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN);

   nsresult rv = nsFrame::DidReflow(aPresContext, aReflowState, aStatus);

   mState |= preserveBits;

   return rv;

 }

 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::GetMinWidth(nsRenderingContext *aRenderingContext)

 {

   nscoord result;

   DISPLAY_MIN_WIDTH(this, result);

   nsBoxLayoutState state(PresContext(), aRenderingContext);

   nsSize minSize = GetMinSize(state);

   // GetMinSize 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 GetMinSize added, which is the

   // result of GetBorderAndPadding.

   nsMargin bp;

   GetBorderAndPadding(bp);

   result = minSize.width - bp.LeftRight();

   result = std::max(result, 0);

   return result;

 }

 /* virtual */ nscoord

 nsBoxFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)

 {

   nscoord result;

   DISPLAY_PREF_WIDTH(this, result);

   nsBoxLayoutState state(PresContext(), aRenderingContext);

   nsSize prefSize = GetPrefSize(state);

   // GetPrefSize 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 GetPrefSize added, which is the

   // result of GetBorderAndPadding.

   nsMargin bp;

   GetBorderAndPadding(bp);

   result = prefSize.width - bp.LeftRight();

   result = std::max(result, 0);

   return result;

 }

 nsresult

 nsBoxFrame::Reflow(nsPresContext*          aPresContext,

                    nsHTMLReflowMetrics&     aDesiredSize,

                    const nsHTMLReflowState& aReflowState,

                    nsReflowStatus&          aStatus)

 {

   // 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, aReflowState, aDesiredSize, aStatus);

   NS_ASSERTION(aReflowState.ComputedWidth() >=0 &&

                aReflowState.ComputedHeight() >= 0, "Computed Size < 0");

 #ifdef DO_NOISY_REFLOW

   printf("\n-------------Starting BoxFrame Reflow ----------------------------\n");

   printf("%p ** nsBF::Reflow %d ", this, myCounter++);

   printSize("AW", aReflowState.AvailableWidth());

   printSize("AH", aReflowState.AvailableHeight());

   printSize("CW", aReflowState.ComputedWidth());

   printSize("CH", aReflowState.ComputedHeight());

   printf(" *\n");

 #endif

   aStatus = NS_FRAME_COMPLETE;

   // create the layout state

   nsBoxLayoutState state(aPresContext, aReflowState.rendContext,

                          &aReflowState, aReflowState.mReflowDepth);

   nsSize computedSize(aReflowState.ComputedWidth(),aReflowState.ComputedHeight());

   nsMargin m;

   m = aReflowState.ComputedPhysicalBorderPadding();

   // GetBorderAndPadding(m);

   nsSize prefSize(0,0);

   // if we are told to layout intrinsic then get our preferred size.

   NS_ASSERTION(computedSize.width != NS_INTRINSICSIZE,

                "computed width should always be computed");

   if (computedSize.height == NS_INTRINSICSIZE) {

     prefSize = GetPrefSize(state);

     nsSize minSize = GetMinSize(state);

     nsSize maxSize = GetMaxSize(state);

     // XXXbz isn't GetPrefSize supposed to bounds-check for us?

     prefSize = BoundsCheck(minSize, prefSize, maxSize);

   }

   // get our desiredSize

   computedSize.width += m.left + m.right;

   if (aReflowState.ComputedHeight() == NS_INTRINSICSIZE) {

     computedSize.height = prefSize.height;

     // prefSize is border-box but min/max constraints are content-box.

     nscoord verticalBorderPadding =

       aReflowState.ComputedPhysicalBorderPadding().TopBottom();

     nscoord contentHeight = computedSize.height - verticalBorderPadding;

     // Note: contentHeight might be negative, but that's OK because min-height

     // is never negative.

     computedSize.height = aReflowState.ApplyMinMaxHeight(contentHeight) +

                           verticalBorderPadding;

   } else {

     computedSize.height += m.top + m.bottom;

   }

   nsRect r(mRect.x, mRect.y, computedSize.width, computedSize.height);

   SetBounds(state, r);

   // layout our children

   Layout(state);

   // ok our child could have gotten bigger. So lets get its bounds

   // get the ascent

   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 = GetBoxAscent(state);

   }

   aDesiredSize.Width() = mRect.width;

   aDesiredSize.Height() = mRect.height;

   aDesiredSize.SetTopAscent(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, aReflowState, aStatus);

   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);

   return NS_OK;

 }

 nsSize

 nsBoxFrame::GetPrefSize(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 (IsCollapsed())

     return size;

   // if the size was not completely redefined in CSS then ask our children

   bool widthSet, heightSet;

   if (!nsIFrame::AddCSSPrefSize(this, size, widthSet, heightSet))

   {

     if (mLayoutManager) {

       nsSize layoutSize = mLayoutManager->GetPrefSize(this, aBoxLayoutState);

       if (!widthSet)

         size.width = layoutSize.width;

       if (!heightSet)

         size.height = layoutSize.height;

     }

     else {

       size = nsBox::GetPrefSize(aBoxLayoutState);

     }

   }

   nsSize minSize = GetMinSize(aBoxLayoutState);

   nsSize maxSize = GetMaxSize(aBoxLayoutState);

   mPrefSize = BoundsCheck(minSize, size, maxSize);

   return mPrefSize;

 }

 nscoord

 nsBoxFrame::GetBoxAscent(nsBoxLayoutState& aBoxLayoutState)

 {

   if (!DoesNeedRecalc(mAscent))

      return mAscent;

 #ifdef DEBUG_LAYOUT

   PropagateDebug(aBoxLayoutState);

 #endif

   if (IsCollapsed())

     return 0;

   if (mLayoutManager)

     mAscent = mLayoutManager->GetAscent(this, aBoxLayoutState);

   else

     mAscent = nsBox::GetBoxAscent(aBoxLayoutState);

   return mAscent;

 }

 nsSize

 nsBoxFrame::GetMinSize(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 (IsCollapsed())

     return size;

   // if the size was not completely redefined in CSS then ask our children

   bool widthSet, heightSet;

   if (!nsIFrame::AddCSSMinSize(aBoxLayoutState, this, size, widthSet, heightSet))

   {

     if (mLayoutManager) {

       nsSize layoutSize = mLayoutManager->GetMinSize(this, aBoxLayoutState);

       if (!widthSet)

         size.width = layoutSize.width;

       if (!heightSet)

         size.height = layoutSize.height;

     }

     else {

       size = nsBox::GetMinSize(aBoxLayoutState);

     }

   }

   mMinSize = size;

   return size;

 }

 nsSize

 nsBoxFrame::GetMaxSize(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 (IsCollapsed())

     return size;

   // if the size was not completely redefined in CSS then ask our children

   bool widthSet, heightSet;

   if (!nsIFrame::AddCSSMaxSize(this, size, widthSet, heightSet))

   {

     if (mLayoutManager) {

       nsSize layoutSize = mLayoutManager->GetMaxSize(this, aBoxLayoutState);

       if (!widthSet)

         size.width = layoutSize.width;

       if (!heightSet)

         size.height = layoutSize.height;

     }

     else {

       size = nsBox::GetMaxSize(aBoxLayoutState);

     }

   }

   mMaxSize = size;

   return size;

 }

 nscoord

 nsBoxFrame::GetFlex(nsBoxLayoutState& aBoxLayoutState)

 {

   if (!DoesNeedRecalc(mFlex))

      return mFlex;

   mFlex = nsBox::GetFlex(aBoxLayoutState);

   return mFlex;

 }

 /**

  * If subclassing please subclass this method not layout. 

  * layout will call this method.

  */

 NS_IMETHODIMP

 nsBoxFrame::DoLayout(nsBoxLayoutState& aState)

 {

   uint32_t oldFlags = aState.LayoutFlags();

   aState.SetLayoutFlags(0);

   nsresult rv = NS_OK;

   if (mLayoutManager) {

     CoordNeedsRecalc(mAscent);

     rv = mLayoutManager->Layout(this, aState);

   }

   aState.SetLayoutFlags(oldFlags);

   if (HasAbsolutelyPositionedChildren()) {

     // Set up a |reflowState| to pass into ReflowAbsoluteFrames

     nsHTMLReflowState reflowState(aState.PresContext(), this,

                                   aState.GetRenderingContext(),

                                   nsSize(mRect.width, NS_UNCONSTRAINEDSIZE));

     // Set up a |desiredSize| to pass into ReflowAbsoluteFrames

     nsHTMLReflowMetrics desiredSize(reflowState);

     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 = GetBoxAscent(aState);

     }

     desiredSize.SetTopAscent(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,

                          reflowState, 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

   SetLayoutManager(nullptr);

   nsContainerFrame::DestroyFrom(aDestructRoot);

 } 

 #ifdef DEBUG_LAYOUT

 nsresult

 nsBoxFrame::SetDebug(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);

     MarkIntrinsicWidthsDirty();

   }

   return NS_OK;

 }

 #endif

 /* virtual */ void

 nsBoxFrame::MarkIntrinsicWidthsDirty()

 {

   SizeNeedsRecalc(mPrefSize);

   SizeNeedsRecalc(mMinSize);

   SizeNeedsRecalc(mMaxSize);

   CoordNeedsRecalc(mFlex);

   CoordNeedsRecalc(mAscent);

   if (mLayoutManager) {

     nsBoxLayoutState state(PresContext());

     mLayoutManager->IntrinsicWidthsDirty(this, state);

   }

   // Don't call base class method, since everything it does is within an

   // IsBoxWrapped check.

 }

 nsresult

 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);

   return NS_OK;

 }

 nsresult

 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);

    return NS_OK;

 }

 nsresult

 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);

    }

    return NS_OK;

 }

 /* virtual */ nsIFrame*

 nsBoxFrame::GetContentInsertionFrame()

 {

   if (GetStateBits() & NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK)

     return GetFirstPrincipalChild()->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>.

   nsIAtom *tag = mContent->Tag();

   if ((tag == nsGkAtoms::window ||

        tag == nsGkAtoms::page ||

        tag == nsGkAtoms::dialog ||

        tag == 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) {

     nsBoxLayoutState state(PresContext());

     nsIFrame* parent = GetParentBox();

     // 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 RelayoutChildAtOrdinal() only handles

     // principal children.

     if (parent && !(GetStateBits() & NS_FRAME_OUT_OF_FLOW) &&

         StyleDisplay()->mDisplay != NS_STYLE_DISPLAY_POPUP) {

       parent->RelayoutChildAtOrdinal(state, 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 &&

            tag == 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(nsPresContext* aPresContext)

 {

     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, ToReferenceFrame());

 }

 static void

 PaintXULDebugBackground(nsIFrame* aFrame, nsRenderingContext* aCtx,

                         const nsRect& aDirtyRect, nsPoint aPt)

 {

   static_cast<nsBoxFrame*>(aFrame)->PaintXULDebugBackground(*aCtx, aPt);

 }

 #endif

 void

 nsBoxFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                              const nsRect&           aDirtyRect,

                              const nsDisplayListSet& aLists)

 {

   // forcelayer is only supported on XUL elements with box layout

   bool forceLayer =

     GetContent()->HasAttr(kNameSpaceID_None, nsGkAtoms::layer) &&

     GetContent()->IsXUL();

   // Check for frames that are marked as a part of the region used

   // in calculating glass margins on Windows.

   if (GetContent()->IsXUL()) {

       const nsStyleDisplay* styles = StyleDisplay();

       if (styles && styles->mAppearance == NS_THEME_WIN_EXCLUDE_GLASS) {

         nsRect rect = nsRect(aBuilder->ToReferenceFrame(this), GetSize());

         aBuilder->AddExcludedGlassRegion(rect);

       }

   }

   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(nsRenderingContext& aRenderingContext,

                                     nsPoint aPt)

 {

   nsMargin border;

   GetBorder(border);

   nsMargin debugBorder;

   nsMargin debugMargin;

   nsMargin debugPadding;

   bool isHorizontal = IsHorizontal();

   GetDebugBorder(debugBorder);

   PixelMarginToTwips(GetPresContext(), debugBorder);

   GetDebugMargin(debugMargin);

   PixelMarginToTwips(GetPresContext(), debugMargin);

   GetDebugPadding(debugPadding);

   PixelMarginToTwips(GetPresContext(), debugPadding);

   nsRect inner(mRect);

   inner.MoveTo(aPt);

   inner.Deflate(debugMargin);

   inner.Deflate(border);

   //nsRect borderRect(inner);

   nscolor color;

   if (isHorizontal) {

     color = NS_RGB(0,0,255);

   } else {

     color = NS_RGB(255,0,0);

   }

   aRenderingContext.SetColor(color);

   //left

   nsRect r(inner);

   r.width = debugBorder.left;

   aRenderingContext.FillRect(r);

   // top

   r = inner;

   r.height = debugBorder.top;

   aRenderingContext.FillRect(r);

   //right

   r = inner;

   r.x = r.x + r.width - debugBorder.right;

   r.width = debugBorder.right;

   aRenderingContext.FillRect(r);

   //bottom

   r = inner;

   r.y = r.y + r.height - debugBorder.bottom;

   r.height = debugBorder.bottom;

   aRenderingContext.FillRect(r);

   // if we have dirty children or we are dirty 

   // place a green border around us.

   if (NS_SUBTREE_DIRTY(this)) {

      nsRect dirtyr(inner);

      aRenderingContext.SetColor(NS_RGB(0,255,0));

      aRenderingContext.DrawRect(dirtyr);

      aRenderingContext.SetColor(color);

   }

 }

 void

 nsBoxFrame::PaintXULDebugOverlay(nsRenderingContext& aRenderingContext,

                                  nsPoint aPt)

   nsMargin border;

   GetBorder(border);

   nsMargin debugMargin;

   GetDebugMargin(debugMargin);

   PixelMarginToTwips(GetPresContext(), debugMargin);

   nsRect inner(mRect);

   inner.MoveTo(aPt);

   inner.Deflate(debugMargin);

   inner.Deflate(border);

   nscoord onePixel = GetPresContext()->IntScaledPixelsToTwips(1);

   kid = GetChildBox();

   while (nullptr != kid) {

     bool isHorizontal = IsHorizontal();

     nscoord x, y, borderSize, spacerSize;

     nsRect cr(kid->mRect);

     nsMargin margin;

     kid->GetMargin(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;

     }

     nsBoxLayoutState state(GetPresContext());

     nscoord flex = kid->GetFlex(state);

     if (!kid->IsCollapsed()) {

       aRenderingContext.SetColor(NS_RGB(255,255,255));

       if (isHorizontal) 

           borderSize = cr.width;

       else 

           borderSize = cr.height;

       DrawSpacer(GetPresContext(), aRenderingContext, isHorizontal, flex, x, y, borderSize, spacerSize);

     }

     kid = kid->GetNextBox();

   }

 }

 #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::GetDebug(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(nsRenderingContext& aRenderingContext, bool aHorizontal, nscoord x1, nscoord y1, nscoord x2, nscoord y2)

 {

     if (aHorizontal)

        aRenderingContext.DrawLine(x1,y1,x2,y2);

     else

        aRenderingContext.DrawLine(y1,x1,y2,x2);

 }

 void

 nsBoxFrame::FillRect(nsRenderingContext& aRenderingContext, bool aHorizontal, nscoord x, nscoord y, nscoord width, nscoord height)

 {

     if (aHorizontal)

        aRenderingContext.FillRect(x,y,width,height);

     else

        aRenderingContext.FillRect(y,x,height,width);

 }

 void 

 nsBoxFrame::DrawSpacer(nsPresContext* aPresContext, nsRenderingContext& aRenderingContext, 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(aRenderingContext, aHorizontal, x,y + spacerSize/2, x + size, y + spacerSize/2);

         } else {

             for (int i=0; i < coils; i++)

             {

                    DrawLine(aRenderingContext, aHorizontal, offset, center+halfSpacer, offset+halfCoilSize, center-halfSpacer);

                    DrawLine(aRenderingContext, aHorizontal, offset+halfCoilSize, center-halfSpacer, offset+coilSize, center+halfSpacer);

                    offset += coilSize;

             }

         }

         FillRect(aRenderingContext, aHorizontal, x + size - spacerSize/2, y, spacerSize/2, spacerSize);

         FillRect(aRenderingContext, aHorizontal, x, y, spacerSize/2, spacerSize);

         //DrawKnob(aPresContext, aRenderingContext, x + size - spacerSize, y, spacerSize);

 }

 void

 nsBoxFrame::GetDebugBorder(nsMargin& aInset)

 {

     aInset.SizeTo(2,2,2,2);

     if (IsHorizontal()) 

        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(nsPresContext* aPresContext, 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->GetBorderAndPadding(border);

     insideBorder.Deflate(border);

     bool isHorizontal = IsHorizontal();

     if (!insideBorder.Contains(nsPoint(x,y)))

         return NS_ERROR_FAILURE;

     //printf("%%%%%% inside box %%%%%%%\n");

     int count = 0;

     nsIFrame* child = aBox->GetChildBox();

     nsMargin m;

     nsMargin m2;

     GetDebugBorder(m);

     PixelMarginToTwips(aPresContext, m);

     GetDebugMargin(m2);

     PixelMarginToTwips(aPresContext, 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");

                       DumpBox(stdout);

                       printf("\n");

                     }

                     if (child->GetContent()) {

                         printf("child #%d: ", count);

                         child->DumpBox(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::AddCSSPrefSize(child, prefSizeCSS, widthSet, heightSet);

                     nsIFrame::AddCSSMinSize (state, child, minSizeCSS, widthSet, heightSet);

                     nsIFrame::AddCSSMaxSize (child, maxSizeCSS, widthSet, heightSet);

                     nsIFrame::AddCSSFlex    (state, child, flexCSS);

                     nsSize prefSize = child->GetPrefSize(state);

                     nsSize minSize = child->GetMinSize(state);

                     nsSize maxSize = child->GetMaxSize(state);

                     nscoord flexSize = child->GetFlex(state);

                     nscoord ascentSize = child->GetBoxAscent(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 = child->GetNextBox();

           count++;

         }

     } else {

     }

     mDebugChild = nullptr;

     return NS_OK;

 }

 void

 nsBoxFrame::SetDebugOnChildList(nsBoxLayoutState& aState, nsIFrame* aChild, bool aDebug)

 {

     nsIFrame* child = GetChildBox();

      while (child)

      {

         child->SetDebug(aState, aDebug);

         child = child->GetNextBox();

      }

 }

 nsresult

 nsBoxFrame::GetFrameSizeWithMargin(nsIFrame* aBox, nsSize& aSize)

 {

   nsRect rect(aBox->GetRect());

   nsMargin margin(0,0,0,0);

   aBox->GetMargin(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);

   // find out what type of element this is

   nsIAtom *atom = mContent->Tag();

   // only support accesskeys for the following elements

   if (atom != nsGkAtoms::button &&

       atom != nsGkAtoms::toolbarbutton &&

       atom != nsGkAtoms::checkbox &&

       atom != nsGkAtoms::textbox &&

       atom != nsGkAtoms::tab &&

       atom != 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->GetOrdinal() <= aRealFrame2->GetOrdinal();

 }

 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->SetBounds(aState, aRect);

   bool layout = NS_SUBTREE_DIRTY(aBox);

   if (layout || (oldRect.width != aRect.width || oldRect.height != aRect.height))  {

     return aBox->Layout(aState);

   }

   return NS_OK;

 }

 nsresult

 nsBoxFrame::RelayoutChildAtOrdinal(nsBoxLayoutState& aState, nsIFrame* aChild)

 {

   if (!SupportsOrdinalsInChildren())

     return NS_OK;

   uint32_t ord = aChild->GetOrdinal();

   nsIFrame* child = mFrames.FirstChild();

   nsIFrame* newPrevSib = nullptr;

   while (child) {

     if (ord < child->GetOrdinal()) {

       break;

     }

     if (child != aChild) {

       newPrevSib = child;

     }

     child = child->GetNextBox();

   }

   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) MOZ_OVERRIDE;

   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:

   nsXULEventRedirectorWrapper(nsIFrame* aTargetFrame)

       : mTargetFrame(aTargetFrame) {}

   virtual nsDisplayItem* WrapList(nsDisplayListBuilder* aBuilder,

                                   nsIFrame* aFrame,

                                   nsDisplayList* aList) MOZ_OVERRIDE {

     return new (aBuilder)

         nsDisplayXULEventRedirector(aBuilder, aFrame, aList, mTargetFrame);

   }

   virtual nsDisplayItem* WrapItem(nsDisplayListBuilder* aBuilder,

                                   nsDisplayItem* aItem) MOZ_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) {

   nsIntPoint refPoint;

   bool res = GetEventPoint(aEvent, refPoint);

   aPoint = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, refPoint, this);

   return res;

 }

 bool

 nsBoxFrame::GetEventPoint(WidgetGUIEvent* aEvent, nsIntPoint &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->touches.Length() != 1) {

       return false;

     }

     dom::Touch* touch = touchEvent->touches.SafeElementAt(0);

     if (!touch) {

       return false;

     }

     aPoint = touch->mRefPoint;

   } else {

     aPoint = LayoutDeviceIntPoint::ToUntyped(aEvent->refPoint);

   }

   return true;

 }