The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "mozilla/AsyncEventDispatcher.h"

 #include "mozilla/ContentEvents.h"

 #include "mozilla/DebugOnly.h"

 #include "mozilla/EventDispatcher.h"

 #include "mozilla/MathAlgorithms.h"

 #include "mozilla/MouseEvents.h"

 #include "mozilla/Likely.h"

 #include "nsCOMPtr.h"

 #include "nsPresContext.h"

 #include "nsNameSpaceManager.h"

 #include "nsTreeBodyFrame.h"

 #include "nsTreeSelection.h"

 #include "nsTreeImageListener.h"

 #include "nsGkAtoms.h"

 #include "nsCSSAnonBoxes.h"

 #include "nsIContent.h"

 #include "nsStyleContext.h"

 #include "nsIBoxObject.h"

 #include "nsIDOMCustomEvent.h"

 #include "nsIDOMMouseEvent.h"

 #include "nsIDOMElement.h"

 #include "nsIDOMNodeList.h"

 #include "nsIDOMDocument.h"

 #include "nsIDOMXULElement.h"

 #include "nsIDocument.h"

 #include "mozilla/css/StyleRule.h"

 #include "nsCSSRendering.h"

 #include "nsIXULTemplateBuilder.h"

 #include "nsXPIDLString.h"

 #include "nsContainerFrame.h"

 #include "nsView.h"

 #include "nsViewManager.h"

 #include "nsWidgetsCID.h"

 #include "nsBoxFrame.h"

 #include "nsBoxObject.h"

 #include "nsIURL.h"

 #include "nsNetUtil.h"

 #include "nsBoxLayoutState.h"

 #include "nsTreeContentView.h"

 #include "nsTreeUtils.h"

 #include "nsITheme.h"

 #include "imgIRequest.h"

 #include "imgIContainer.h"

 #include "imgILoader.h"

 #include "nsINodeInfo.h"

 #include "nsContentUtils.h"

 #include "nsLayoutUtils.h"

 #include "nsIScrollableFrame.h"

 #include "nsDisplayList.h"

 #include "nsTreeBoxObject.h"

 #include "nsRenderingContext.h"

 #include "nsIScriptableRegion.h"

 #include <algorithm>

 #include "ScrollbarActivity.h"

 #ifdef ACCESSIBILITY

 #include "nsAccessibilityService.h"

 #include "nsIWritablePropertyBag2.h"

 #endif

 #include "nsBidiUtils.h"

 using namespace mozilla;

 using namespace mozilla::layout;

 // Enumeration function that cancels all the image requests in our cache

 static PLDHashOperator

 CancelImageRequest(const nsAString& aKey,

                    nsTreeImageCacheEntry aEntry, void* aData)

 {

   // If our imgIRequest object was registered with the refresh driver,

   // then we need to deregister it.

   nsTreeBodyFrame* frame = static_cast<nsTreeBodyFrame*>(aData);

   nsLayoutUtils::DeregisterImageRequest(frame->PresContext(), aEntry.request,

                                         nullptr);

   aEntry.request->CancelAndForgetObserver(NS_BINDING_ABORTED);

   return PL_DHASH_NEXT;

 }

 //

 // NS_NewTreeFrame

 //

 // Creates a new tree frame

 //

 nsIFrame*

 NS_NewTreeBodyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)

 {

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

 }

 NS_IMPL_FRAMEARENA_HELPERS(nsTreeBodyFrame)

 NS_QUERYFRAME_HEAD(nsTreeBodyFrame)

   NS_QUERYFRAME_ENTRY(nsIScrollbarMediator)

   NS_QUERYFRAME_ENTRY(nsIScrollbarOwner)

   NS_QUERYFRAME_ENTRY(nsTreeBodyFrame)

 NS_QUERYFRAME_TAIL_INHERITING(nsLeafBoxFrame)

 // Constructor

 nsTreeBodyFrame::nsTreeBodyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)

 :nsLeafBoxFrame(aPresShell, aContext),

  mSlots(nullptr),

  mImageCache(16),

  mTopRowIndex(0),

  mPageLength(0),

  mHorzPosition(0),

  mOriginalHorzWidth(-1),

  mHorzWidth(0),

  mAdjustWidth(0),

  mRowHeight(0),

  mIndentation(0),

  mStringWidth(-1),

  mUpdateBatchNest(0),

  mRowCount(0),

  mMouseOverRow(-1),

  mFocused(false),

  mHasFixedRowCount(false),

  mVerticalOverflow(false),

  mHorizontalOverflow(false),

  mReflowCallbackPosted(false),

  mCheckingOverflow(false)

 {

   mColumns = new nsTreeColumns(this);

 }

 // Destructor

 nsTreeBodyFrame::~nsTreeBodyFrame()

 {

   mImageCache.EnumerateRead(CancelImageRequest, this);

   DetachImageListeners();

   delete mSlots;

 }

 static void

 GetBorderPadding(nsStyleContext* aContext, nsMargin& aMargin)

 {

   aMargin.SizeTo(0, 0, 0, 0);

   if (!aContext->StylePadding()->GetPadding(aMargin)) {

     NS_NOTYETIMPLEMENTED("percentage padding");

   }

   aMargin += aContext->StyleBorder()->GetComputedBorder();

 }

 static void

 AdjustForBorderPadding(nsStyleContext* aContext, nsRect& aRect)

 {

   nsMargin borderPadding(0, 0, 0, 0);

   GetBorderPadding(aContext, borderPadding);

   aRect.Deflate(borderPadding);

 }

 void

 nsTreeBodyFrame::Init(nsIContent*     aContent,

                       nsIFrame*       aParent,

                       nsIFrame*       aPrevInFlow)

 {

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

   mIndentation = GetIndentation();

   mRowHeight = GetRowHeight();

   EnsureBoxObject();

   if (LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars) != 0) {

     mScrollbarActivity = new ScrollbarActivity(

                            static_cast<nsIScrollbarOwner*>(this));

   }

 }

 nsSize

 nsTreeBodyFrame::GetMinSize(nsBoxLayoutState& aBoxLayoutState)

 {

   EnsureView();

   nsIContent* baseElement = GetBaseElement();

   nsSize min(0,0);

   int32_t desiredRows;

   if (MOZ_UNLIKELY(!baseElement)) {

     desiredRows = 0;

   }

   else if (baseElement->Tag() == nsGkAtoms::select &&

            baseElement->IsHTML()) {

     min.width = CalcMaxRowWidth();

     nsAutoString size;

     baseElement->GetAttr(kNameSpaceID_None, nsGkAtoms::size, size);

     if (!size.IsEmpty()) {

       nsresult err;

       desiredRows = size.ToInteger(&err);

       mHasFixedRowCount = true;

       mPageLength = desiredRows;

     }

     else {

       desiredRows = 1;

     }

   }

   else {

     // tree

     nsAutoString rows;

     baseElement->GetAttr(kNameSpaceID_None, nsGkAtoms::rows, rows);

     if (!rows.IsEmpty()) {

       nsresult err;

       desiredRows = rows.ToInteger(&err);

       mPageLength = desiredRows;

     }

     else {

       desiredRows = 0;

     }

   }

   min.height = mRowHeight * desiredRows;

   AddBorderAndPadding(min);

   bool widthSet, heightSet;

   nsIFrame::AddCSSMinSize(aBoxLayoutState, this, min, widthSet, heightSet);

   return min;

 }

 nscoord

 nsTreeBodyFrame::CalcMaxRowWidth()

 {

   if (mStringWidth != -1)

     return mStringWidth;

   if (!mView)

     return 0;

   nsStyleContext* rowContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreerow);

   nsMargin rowMargin(0,0,0,0);

   GetBorderPadding(rowContext, rowMargin);

   nscoord rowWidth;

   nsTreeColumn* col;

   nsRefPtr<nsRenderingContext> rc =

     PresContext()->PresShell()->CreateReferenceRenderingContext();

   for (int32_t row = 0; row < mRowCount; ++row) {

     rowWidth = 0;

     for (col = mColumns->GetFirstColumn(); col; col = col->GetNext()) {

       nscoord desiredWidth, currentWidth;

       nsresult rv = GetCellWidth(row, col, rc, desiredWidth, currentWidth);

       if (NS_FAILED(rv)) {

         NS_NOTREACHED("invalid column");

         continue;

       }

       rowWidth += desiredWidth;

     }

     if (rowWidth > mStringWidth)

       mStringWidth = rowWidth;

   }

   mStringWidth += rowMargin.left + rowMargin.right;

   return mStringWidth;

 }

 void

 nsTreeBodyFrame::DestroyFrom(nsIFrame* aDestructRoot)

 {

   if (mScrollbarActivity) {

     mScrollbarActivity->Destroy();

     mScrollbarActivity = nullptr;

   }

   mScrollEvent.Revoke();

   // Make sure we cancel any posted callbacks. 

   if (mReflowCallbackPosted) {

     PresContext()->PresShell()->CancelReflowCallback(this);

     mReflowCallbackPosted = false;

   }

   if (mColumns)

     mColumns->SetTree(nullptr);

   // Save off our info into the box object.

   nsCOMPtr<nsPIBoxObject> box(do_QueryInterface(mTreeBoxObject));

   if (box) {

     if (mTopRowIndex > 0) {

       nsAutoString topRowStr; topRowStr.AssignLiteral("topRow");

       nsAutoString topRow;

       topRow.AppendInt(mTopRowIndex);

       box->SetProperty(topRowStr.get(), topRow.get());

     }

     // Always null out the cached tree body frame.

     box->ClearCachedValues();

     mTreeBoxObject = nullptr; // Drop our ref here.

   }

   if (mView) {

     nsCOMPtr<nsITreeSelection> sel;

     mView->GetSelection(getter_AddRefs(sel));

     if (sel)

       sel->SetTree(nullptr);

     mView->SetTree(nullptr);

     mView = nullptr;

   }

   nsLeafBoxFrame::DestroyFrom(aDestructRoot);

 }

 void

 nsTreeBodyFrame::EnsureBoxObject()

 {

   if (!mTreeBoxObject) {

     nsIContent* parent = GetBaseElement();

     if (parent) {

       nsIDocument* nsDoc = parent->GetDocument();

       if (!nsDoc) // there may be no document, if we're called from Destroy()

         return;

       ErrorResult ignored;

       nsCOMPtr<nsIBoxObject> box =

         nsDoc->GetBoxObjectFor(parent->AsElement(), ignored);

       // Ensure that we got a native box object.

       nsCOMPtr<nsPIBoxObject> pBox = do_QueryInterface(box);

       if (pBox) {

         nsCOMPtr<nsITreeBoxObject> realTreeBoxObject = do_QueryInterface(pBox);

         if (realTreeBoxObject) {

           nsTreeBodyFrame* innerTreeBoxObject =

             static_cast<nsTreeBoxObject*>(realTreeBoxObject.get())

               ->GetCachedTreeBody();

           ENSURE_TRUE(!innerTreeBoxObject || innerTreeBoxObject == this);

           mTreeBoxObject = realTreeBoxObject;

         }

       }

     }

   }

 }

 void

 nsTreeBodyFrame::EnsureView()

 {

   if (!mView) {

     if (PresContext()->PresShell()->IsReflowLocked()) {

       if (!mReflowCallbackPosted) {

         mReflowCallbackPosted = true;

         PresContext()->PresShell()->PostReflowCallback(this);

       }

       return;

     }

     nsCOMPtr<nsIBoxObject> box = do_QueryInterface(mTreeBoxObject);

     if (box) {

       nsWeakFrame weakFrame(this);

       nsCOMPtr<nsITreeView> treeView;

       mTreeBoxObject->GetView(getter_AddRefs(treeView));

       if (treeView && weakFrame.IsAlive()) {

         nsXPIDLString rowStr;

         box->GetProperty(MOZ_UTF16("topRow"),

                          getter_Copies(rowStr));

         nsAutoString rowStr2(rowStr);

         nsresult error;

         int32_t rowIndex = rowStr2.ToInteger(&error);

         // Set our view.

         SetView(treeView);

         ENSURE_TRUE(weakFrame.IsAlive());

         // Scroll to the given row.

         // XXX is this optimal if we haven't laid out yet?

         ScrollToRow(rowIndex);

         ENSURE_TRUE(weakFrame.IsAlive());

         // Clear out the property info for the top row, but we always keep the

         // view current.

         box->RemoveProperty(MOZ_UTF16("topRow"));

       }

     }

   }

 }

 void

 nsTreeBodyFrame::ManageReflowCallback(const nsRect& aRect, nscoord aHorzWidth)

 {

   if (!mReflowCallbackPosted &&

       (!aRect.IsEqualEdges(mRect) || mHorzWidth != aHorzWidth)) {

     PresContext()->PresShell()->PostReflowCallback(this);

     mReflowCallbackPosted = true;

     mOriginalHorzWidth = mHorzWidth;

   }

   else if (mReflowCallbackPosted &&

            mHorzWidth != aHorzWidth && mOriginalHorzWidth == aHorzWidth) {

     PresContext()->PresShell()->CancelReflowCallback(this);

     mReflowCallbackPosted = false;

     mOriginalHorzWidth = -1;

   }

 }

 void

 nsTreeBodyFrame::SetBounds(nsBoxLayoutState& aBoxLayoutState, const nsRect& aRect,

                            bool aRemoveOverflowArea)

 {

   nscoord horzWidth = CalcHorzWidth(GetScrollParts());

   ManageReflowCallback(aRect, horzWidth);

   mHorzWidth = horzWidth;

   nsLeafBoxFrame::SetBounds(aBoxLayoutState, aRect, aRemoveOverflowArea);

 }

 bool

 nsTreeBodyFrame::ReflowFinished()

 {

   if (!mView) {

     nsWeakFrame weakFrame(this);

     EnsureView();

     NS_ENSURE_TRUE(weakFrame.IsAlive(), false);

   }

   if (mView) {

     CalcInnerBox();

     ScrollParts parts = GetScrollParts();

     mHorzWidth = CalcHorzWidth(parts);

     if (!mHasFixedRowCount) {

       mPageLength = mInnerBox.height / mRowHeight;

     }

     int32_t lastPageTopRow = std::max(0, mRowCount - mPageLength);

     if (mTopRowIndex > lastPageTopRow)

       ScrollToRowInternal(parts, lastPageTopRow);

     nsIContent *treeContent = GetBaseElement();

     if (treeContent &&

         treeContent->AttrValueIs(kNameSpaceID_None,

                                  nsGkAtoms::keepcurrentinview,

                                  nsGkAtoms::_true, eCaseMatters)) {

       // make sure that the current selected item is still

       // visible after the tree changes size.

       nsCOMPtr<nsITreeSelection> sel;

       mView->GetSelection(getter_AddRefs(sel));

       if (sel) {

         int32_t currentIndex;

         sel->GetCurrentIndex(&currentIndex);

         if (currentIndex != -1)

           EnsureRowIsVisibleInternal(parts, currentIndex);

       }

     }

     if (!FullScrollbarsUpdate(false)) {

       return false;

     }

   }

   mReflowCallbackPosted = false;

   return false;

 }

 void

 nsTreeBodyFrame::ReflowCallbackCanceled()

 {

   mReflowCallbackPosted = false;

 }

 nsresult

 nsTreeBodyFrame::GetView(nsITreeView * *aView)

 {

   *aView = nullptr;

   nsWeakFrame weakFrame(this);

   EnsureView();

   NS_ENSURE_STATE(weakFrame.IsAlive());

   NS_IF_ADDREF(*aView = mView);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::SetView(nsITreeView * aView)

 {

   // First clear out the old view.

   if (mView) {

     nsCOMPtr<nsITreeSelection> sel;

     mView->GetSelection(getter_AddRefs(sel));

     if (sel)

       sel->SetTree(nullptr);

     mView->SetTree(nullptr);

     // Only reset the top row index and delete the columns if we had an old non-null view.

     mTopRowIndex = 0;

   }

   // Tree, meet the view.

   mView = aView;

   // Changing the view causes us to refetch our data.  This will

   // necessarily entail a full invalidation of the tree.

   Invalidate();

   nsIContent *treeContent = GetBaseElement();

   if (treeContent) {

 #ifdef ACCESSIBILITY

     nsAccessibilityService* accService = nsIPresShell::AccService();

     if (accService)

       accService->TreeViewChanged(PresContext()->GetPresShell(), treeContent, mView);

 #endif

     FireDOMEvent(NS_LITERAL_STRING("TreeViewChanged"), treeContent);

   }

   if (mView) {

     // Give the view a new empty selection object to play with, but only if it

     // doesn't have one already.

     nsCOMPtr<nsITreeSelection> sel;

     mView->GetSelection(getter_AddRefs(sel));

     if (sel) {

       sel->SetTree(mTreeBoxObject);

     }

     else {

       NS_NewTreeSelection(mTreeBoxObject, getter_AddRefs(sel));

       mView->SetSelection(sel);

     }

     // View, meet the tree.

     nsWeakFrame weakFrame(this);

     mView->SetTree(mTreeBoxObject);

     NS_ENSURE_STATE(weakFrame.IsAlive());

     mView->GetRowCount(&mRowCount);

     if (!PresContext()->PresShell()->IsReflowLocked()) {

       // The scrollbar will need to be updated.

       FullScrollbarsUpdate(false);

     } else if (!mReflowCallbackPosted) {

       mReflowCallbackPosted = true;

       PresContext()->PresShell()->PostReflowCallback(this);

     }

   }

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::GetFocused(bool* aFocused)

 {

   *aFocused = mFocused;

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::SetFocused(bool aFocused)

 {

   if (mFocused != aFocused) {

     mFocused = aFocused;

     if (mView) {

       nsCOMPtr<nsITreeSelection> sel;

       mView->GetSelection(getter_AddRefs(sel));

       if (sel)

         sel->InvalidateSelection();

     }

   }

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::GetTreeBody(nsIDOMElement** aElement)

 {

   //NS_ASSERTION(mContent, "no content, see bug #104878");

   if (!mContent)

     return NS_ERROR_NULL_POINTER;

   return mContent->QueryInterface(NS_GET_IID(nsIDOMElement), (void**)aElement);

 }

 nsresult

 nsTreeBodyFrame::GetRowHeight(int32_t* _retval)

 {

   *_retval = nsPresContext::AppUnitsToIntCSSPixels(mRowHeight);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::GetRowWidth(int32_t *aRowWidth)

 {

   *aRowWidth = nsPresContext::AppUnitsToIntCSSPixels(CalcHorzWidth(GetScrollParts()));

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::GetHorizontalPosition(int32_t *aHorizontalPosition)

 {

   *aHorizontalPosition = nsPresContext::AppUnitsToIntCSSPixels(mHorzPosition); 

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::GetSelectionRegion(nsIScriptableRegion **aRegion)

 {

   *aRegion = nullptr;

   nsCOMPtr<nsITreeSelection> selection;

   mView->GetSelection(getter_AddRefs(selection));

   NS_ENSURE_TRUE(selection, NS_OK);

   nsCOMPtr<nsIScriptableRegion> region = do_CreateInstance("@mozilla.org/gfx/region;1");

   NS_ENSURE_TRUE(region, NS_ERROR_FAILURE);

   region->Init();

   nsRefPtr<nsPresContext> presContext = PresContext();

   nsIntRect rect = mRect.ToOutsidePixels(presContext->AppUnitsPerCSSPixel());

   nsIFrame* rootFrame = presContext->PresShell()->GetRootFrame();

   nsPoint origin = GetOffsetTo(rootFrame);

   // iterate through the visible rows and add the selected ones to the

   // drag region

   int32_t x = nsPresContext::AppUnitsToIntCSSPixels(origin.x);

   int32_t y = nsPresContext::AppUnitsToIntCSSPixels(origin.y);

   int32_t top = y;

   int32_t end = LastVisibleRow();

   int32_t rowHeight = nsPresContext::AppUnitsToIntCSSPixels(mRowHeight);

   for (int32_t i = mTopRowIndex; i <= end; i++) {

     bool isSelected;

     selection->IsSelected(i, &isSelected);

     if (isSelected)

       region->UnionRect(x, y, rect.width, rowHeight);

     y += rowHeight;

   }

   // clip to the tree boundary in case one row extends past it

   region->IntersectRect(x, top, rect.width, rect.height);

   NS_ADDREF(*aRegion = region);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::Invalidate()

 {

   if (mUpdateBatchNest)

     return NS_OK;

   InvalidateFrame();

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::InvalidateColumn(nsITreeColumn* aCol)

 {

   if (mUpdateBatchNest)

     return NS_OK;

   nsRefPtr<nsTreeColumn> col = GetColumnImpl(aCol);

   if (!col)

     return NS_ERROR_INVALID_ARG;

 #ifdef ACCESSIBILITY

   if (nsIPresShell::IsAccessibilityActive())

     FireInvalidateEvent(-1, -1, aCol, aCol);

 #endif

   nsRect columnRect;

   nsresult rv = col->GetRect(this, mInnerBox.y, mInnerBox.height, &columnRect);

   NS_ENSURE_SUCCESS(rv, rv);

   // When false then column is out of view

   if (OffsetForHorzScroll(columnRect, true))

       InvalidateFrameWithRect(columnRect);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::InvalidateRow(int32_t aIndex)

 {

   if (mUpdateBatchNest)

     return NS_OK;

 #ifdef ACCESSIBILITY

   if (nsIPresShell::IsAccessibilityActive())

     FireInvalidateEvent(aIndex, aIndex, nullptr, nullptr);

 #endif

   aIndex -= mTopRowIndex;

   if (aIndex < 0 || aIndex > mPageLength)

     return NS_OK;

   nsRect rowRect(mInnerBox.x, mInnerBox.y+mRowHeight*aIndex, mInnerBox.width, mRowHeight);

   InvalidateFrameWithRect(rowRect);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::InvalidateCell(int32_t aIndex, nsITreeColumn* aCol)

 {

   if (mUpdateBatchNest)

     return NS_OK;

 #ifdef ACCESSIBILITY

   if (nsIPresShell::IsAccessibilityActive())

     FireInvalidateEvent(aIndex, aIndex, aCol, aCol);

 #endif

   aIndex -= mTopRowIndex;

   if (aIndex < 0 || aIndex > mPageLength)

     return NS_OK;

   nsRefPtr<nsTreeColumn> col = GetColumnImpl(aCol);

   if (!col)

     return NS_ERROR_INVALID_ARG;

   nsRect cellRect;

   nsresult rv = col->GetRect(this, mInnerBox.y+mRowHeight*aIndex, mRowHeight,

                              &cellRect);

   NS_ENSURE_SUCCESS(rv, rv);

   if (OffsetForHorzScroll(cellRect, true))

     InvalidateFrameWithRect(cellRect);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::InvalidateRange(int32_t aStart, int32_t aEnd)

 {

   if (mUpdateBatchNest)

     return NS_OK;

   if (aStart == aEnd)

     return InvalidateRow(aStart);

   int32_t last = LastVisibleRow();

   if (aStart > aEnd || aEnd < mTopRowIndex || aStart > last)

     return NS_OK;

   if (aStart < mTopRowIndex)

     aStart = mTopRowIndex;

   if (aEnd > last)

     aEnd = last;

 #ifdef ACCESSIBILITY

   if (nsIPresShell::IsAccessibilityActive()) {

     int32_t end =

       mRowCount > 0 ? ((mRowCount <= aEnd) ? mRowCount - 1 : aEnd) : 0;

     FireInvalidateEvent(aStart, end, nullptr, nullptr);

   }

 #endif

   nsRect rangeRect(mInnerBox.x, mInnerBox.y+mRowHeight*(aStart-mTopRowIndex), mInnerBox.width, mRowHeight*(aEnd-aStart+1));

   InvalidateFrameWithRect(rangeRect);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::InvalidateColumnRange(int32_t aStart, int32_t aEnd, nsITreeColumn* aCol)

 {

   if (mUpdateBatchNest)

     return NS_OK;

   nsRefPtr<nsTreeColumn> col = GetColumnImpl(aCol);

   if (!col)

     return NS_ERROR_INVALID_ARG;

   if (aStart == aEnd)

     return InvalidateCell(aStart, col);

   int32_t last = LastVisibleRow();

   if (aStart > aEnd || aEnd < mTopRowIndex || aStart > last)

     return NS_OK;

   if (aStart < mTopRowIndex)

     aStart = mTopRowIndex;

   if (aEnd > last)

     aEnd = last;

 #ifdef ACCESSIBILITY

   if (nsIPresShell::IsAccessibilityActive()) {

     int32_t end =

       mRowCount > 0 ? ((mRowCount <= aEnd) ? mRowCount - 1 : aEnd) : 0;

     FireInvalidateEvent(aStart, end, aCol, aCol);

   }

 #endif

   nsRect rangeRect;

   nsresult rv = col->GetRect(this, 

                              mInnerBox.y+mRowHeight*(aStart-mTopRowIndex),

                              mRowHeight*(aEnd-aStart+1),

                              &rangeRect);

   NS_ENSURE_SUCCESS(rv, rv);

   InvalidateFrameWithRect(rangeRect);

   return NS_OK;

 }

 static void

 FindScrollParts(nsIFrame* aCurrFrame, nsTreeBodyFrame::ScrollParts* aResult)

 {

   if (!aResult->mColumnsScrollFrame) {

     nsIScrollableFrame* f = do_QueryFrame(aCurrFrame);

     if (f) {

       aResult->mColumnsFrame = aCurrFrame;

       aResult->mColumnsScrollFrame = f;

     }

   }

   nsScrollbarFrame *sf = do_QueryFrame(aCurrFrame);

   if (sf) {

     if (!aCurrFrame->IsHorizontal()) {

       if (!aResult->mVScrollbar) {

         aResult->mVScrollbar = sf;

       }

     } else {

       if (!aResult->mHScrollbar) {

         aResult->mHScrollbar = sf;

       }

     }

     // don't bother searching inside a scrollbar

     return;

   }

   nsIFrame* child = aCurrFrame->GetFirstPrincipalChild();

   while (child &&

          !child->GetContent()->IsRootOfNativeAnonymousSubtree() &&

          (!aResult->mVScrollbar || !aResult->mHScrollbar ||

           !aResult->mColumnsScrollFrame)) {

     FindScrollParts(child, aResult);

     child = child->GetNextSibling();

   }

 }

 nsTreeBodyFrame::ScrollParts nsTreeBodyFrame::GetScrollParts()

 {

   ScrollParts result = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };

   nsIContent* baseElement = GetBaseElement();

   nsIFrame* treeFrame =

     baseElement ? baseElement->GetPrimaryFrame() : nullptr;

   if (treeFrame) {

     // The way we do this, searching through the entire frame subtree, is pretty

     // dumb! We should know where these frames are.

     FindScrollParts(treeFrame, &result);

     if (result.mHScrollbar) {

       result.mHScrollbar->SetScrollbarMediatorContent(GetContent());

       nsIFrame* f = do_QueryFrame(result.mHScrollbar);

       result.mHScrollbarContent = f->GetContent();

     }

     if (result.mVScrollbar) {

       result.mVScrollbar->SetScrollbarMediatorContent(GetContent());

       nsIFrame* f = do_QueryFrame(result.mVScrollbar);

       result.mVScrollbarContent = f->GetContent();

     }

   }

   return result;

 }

 void

 nsTreeBodyFrame::UpdateScrollbars(const ScrollParts& aParts)

 {

   nscoord rowHeightAsPixels = nsPresContext::AppUnitsToIntCSSPixels(mRowHeight);

   nsWeakFrame weakFrame(this);

   if (aParts.mVScrollbar) {

     nsAutoString curPos;

     curPos.AppendInt(mTopRowIndex*rowHeightAsPixels);

     aParts.mVScrollbarContent->

       SetAttr(kNameSpaceID_None, nsGkAtoms::curpos, curPos, true);

     // 'this' might be deleted here

   }

   if (weakFrame.IsAlive() && aParts.mHScrollbar) {

     nsAutoString curPos;

     curPos.AppendInt(mHorzPosition);

     aParts.mHScrollbarContent->

       SetAttr(kNameSpaceID_None, nsGkAtoms::curpos, curPos, true);

     // 'this' might be deleted here

   }

   if (weakFrame.IsAlive() && mScrollbarActivity) {

     mScrollbarActivity->ActivityOccurred();

   }

 }

 void

 nsTreeBodyFrame::CheckOverflow(const ScrollParts& aParts)

 {

   bool verticalOverflowChanged = false;

   bool horizontalOverflowChanged = false;

   if (!mVerticalOverflow && mRowCount > mPageLength) {

     mVerticalOverflow = true;

     verticalOverflowChanged = true;

   }

   else if (mVerticalOverflow && mRowCount <= mPageLength) {

     mVerticalOverflow = false;

     verticalOverflowChanged = true;

   }

   if (aParts.mColumnsFrame) {

     nsRect bounds = aParts.mColumnsFrame->GetRect();

     if (bounds.width != 0) {

       /* Ignore overflows that are less than half a pixel. Yes these happen

          all over the place when flex boxes are compressed real small. 

          Probably a result of a rounding errors somewhere in the layout code. */

       bounds.width += nsPresContext::CSSPixelsToAppUnits(0.5f);

       if (!mHorizontalOverflow && bounds.width < mHorzWidth) {

         mHorizontalOverflow = true;

         horizontalOverflowChanged = true;

       } else if (mHorizontalOverflow && bounds.width >= mHorzWidth) {

         mHorizontalOverflow = false;

         horizontalOverflowChanged = true;

       }

     }

   }

   nsWeakFrame weakFrame(this);

   nsRefPtr<nsPresContext> presContext = PresContext();

   nsCOMPtr<nsIPresShell> presShell = presContext->GetPresShell();

   nsCOMPtr<nsIContent> content = mContent;

   if (verticalOverflowChanged) {

     InternalScrollPortEvent event(true,

       mVerticalOverflow ? NS_SCROLLPORT_OVERFLOW : NS_SCROLLPORT_UNDERFLOW,

       nullptr);

     event.orient = InternalScrollPortEvent::vertical;

     EventDispatcher::Dispatch(content, presContext, &event);

   }

   if (horizontalOverflowChanged) {

     InternalScrollPortEvent event(true,

       mHorizontalOverflow ? NS_SCROLLPORT_OVERFLOW : NS_SCROLLPORT_UNDERFLOW,

       nullptr);

     event.orient = InternalScrollPortEvent::horizontal;

     EventDispatcher::Dispatch(content, presContext, &event);

   }

   // The synchronous event dispatch above can trigger reflow notifications.

   // Flush those explicitly now, so that we can guard against potential infinite

   // recursion. See bug 905909.

   if (!weakFrame.IsAlive()) {

     return;

   }

   NS_ASSERTION(!mCheckingOverflow, "mCheckingOverflow should not already be set");

   // Don't use AutoRestore since we want to not touch mCheckingOverflow if we fail

   // the weakFrame.IsAlive() check below

   mCheckingOverflow = true;

   presShell->FlushPendingNotifications(Flush_Layout);

   if (!weakFrame.IsAlive()) {

     return;

   }

   mCheckingOverflow = false;

 }

 void

 nsTreeBodyFrame::InvalidateScrollbars(const ScrollParts& aParts, nsWeakFrame& aWeakColumnsFrame)

 {

   if (mUpdateBatchNest || !mView)

     return;

   nsWeakFrame weakFrame(this);

   if (aParts.mVScrollbar) {

     // Do Vertical Scrollbar 

     nsAutoString maxposStr;

     nscoord rowHeightAsPixels = nsPresContext::AppUnitsToIntCSSPixels(mRowHeight);

     int32_t size = rowHeightAsPixels * (mRowCount > mPageLength ? mRowCount - mPageLength : 0);

     maxposStr.AppendInt(size);

     aParts.mVScrollbarContent->

       SetAttr(kNameSpaceID_None, nsGkAtoms::maxpos, maxposStr, true);

     ENSURE_TRUE(weakFrame.IsAlive());

     // Also set our page increment and decrement.

     nscoord pageincrement = mPageLength*rowHeightAsPixels;

     nsAutoString pageStr;

     pageStr.AppendInt(pageincrement);

     aParts.mVScrollbarContent->

       SetAttr(kNameSpaceID_None, nsGkAtoms::pageincrement, pageStr, true);

     ENSURE_TRUE(weakFrame.IsAlive());

   }

   if (aParts.mHScrollbar && aParts.mColumnsFrame && aWeakColumnsFrame.IsAlive()) {

     // And now Horizontal scrollbar

     nsRect bounds = aParts.mColumnsFrame->GetRect();

     nsAutoString maxposStr;

     maxposStr.AppendInt(mHorzWidth > bounds.width ? mHorzWidth - bounds.width : 0);

     aParts.mHScrollbarContent->

       SetAttr(kNameSpaceID_None, nsGkAtoms::maxpos, maxposStr, true);

     ENSURE_TRUE(weakFrame.IsAlive());

     nsAutoString pageStr;

     pageStr.AppendInt(bounds.width);

     aParts.mHScrollbarContent->

       SetAttr(kNameSpaceID_None, nsGkAtoms::pageincrement, pageStr, true);

     ENSURE_TRUE(weakFrame.IsAlive());

     pageStr.Truncate();

     pageStr.AppendInt(nsPresContext::CSSPixelsToAppUnits(16));

     aParts.mHScrollbarContent->

       SetAttr(kNameSpaceID_None, nsGkAtoms::increment, pageStr, true);

   }

   if (weakFrame.IsAlive() && mScrollbarActivity) {

     mScrollbarActivity->ActivityOccurred();

   }

 }

 // Takes client x/y in pixels, converts them to appunits, and converts into

 // values relative to this nsTreeBodyFrame frame.

 nsPoint

 nsTreeBodyFrame::AdjustClientCoordsToBoxCoordSpace(int32_t aX, int32_t aY)

 {

   nsPoint point(nsPresContext::CSSPixelsToAppUnits(aX),

                 nsPresContext::CSSPixelsToAppUnits(aY));

   nsPresContext* presContext = PresContext();

   point -= GetOffsetTo(presContext->GetPresShell()->GetRootFrame());

   // Adjust by the inner box coords, so that we're in the inner box's

   // coordinate space.

   point -= mInnerBox.TopLeft();

   return point;

 } // AdjustClientCoordsToBoxCoordSpace

 nsresult

 nsTreeBodyFrame::GetRowAt(int32_t aX, int32_t aY, int32_t* _retval)

 {

   if (!mView)

     return NS_OK;

   nsPoint point = AdjustClientCoordsToBoxCoordSpace(aX, aY);

   // Check if the coordinates are above our visible space.

   if (point.y < 0) {

     *_retval = -1;

     return NS_OK;

   }

   *_retval = GetRowAt(point.x, point.y);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::GetCellAt(int32_t aX, int32_t aY, int32_t* aRow, nsITreeColumn** aCol,

                            nsACString& aChildElt)

 {

   if (!mView)

     return NS_OK;

   nsPoint point = AdjustClientCoordsToBoxCoordSpace(aX, aY);

   // Check if the coordinates are above our visible space.

   if (point.y < 0) {

     *aRow = -1;

     return NS_OK;

   }

   nsTreeColumn* col;

   nsIAtom* child;

   GetCellAt(point.x, point.y, aRow, &col, &child);

   if (col) {

     NS_ADDREF(*aCol = col);

     if (child == nsCSSAnonBoxes::moztreecell)

       aChildElt.AssignLiteral("cell");

     else if (child == nsCSSAnonBoxes::moztreetwisty)

       aChildElt.AssignLiteral("twisty");

     else if (child == nsCSSAnonBoxes::moztreeimage)

       aChildElt.AssignLiteral("image");

     else if (child == nsCSSAnonBoxes::moztreecelltext)

       aChildElt.AssignLiteral("text");

   }

   return NS_OK;

 }

 //

 // GetCoordsForCellItem

 //

 // Find the x/y location and width/height (all in PIXELS) of the given object

 // in the given column. 

 //

 // XXX IMPORTANT XXX:

 // Hyatt says in the bug for this, that the following needs to be done:

 // (1) You need to deal with overflow when computing cell rects.  See other column 

 // iteration examples... if you don't deal with this, you'll mistakenly extend the 

 // cell into the scrollbar's rect.

 //

 // (2) You are adjusting the cell rect by the *row" border padding.  That's 

 // wrong.  You need to first adjust a row rect by its border/padding, and then the 

 // cell rect fits inside the adjusted row rect.  It also can have border/padding 

 // as well as margins.  The vertical direction isn't that important, but you need 

 // to get the horizontal direction right.

 //

 // (3) GetImageSize() does not include margins (but it does include border/padding).  

 // You need to make sure to add in the image's margins as well.

 //

 nsresult

 nsTreeBodyFrame::GetCoordsForCellItem(int32_t aRow, nsITreeColumn* aCol, const nsACString& aElement, 

                                       int32_t *aX, int32_t *aY, int32_t *aWidth, int32_t *aHeight)

 {

   *aX = 0;

   *aY = 0;

   *aWidth = 0;

   *aHeight = 0;

   bool isRTL = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;

   nscoord currX = mInnerBox.x - mHorzPosition;

   // The Rect for the requested item. 

   nsRect theRect;

   nsPresContext* presContext = PresContext();

   for (nsTreeColumn* currCol = mColumns->GetFirstColumn(); currCol; currCol = currCol->GetNext()) {

     // The Rect for the current cell.

     nscoord colWidth;

 #ifdef DEBUG

     nsresult rv =

 #endif

       currCol->GetWidthInTwips(this, &colWidth);

     NS_ASSERTION(NS_SUCCEEDED(rv), "invalid column");

     nsRect cellRect(currX, mInnerBox.y + mRowHeight * (aRow - mTopRowIndex),

                     colWidth, mRowHeight);

     // Check the ID of the current column to see if it matches. If it doesn't 

     // increment the current X value and continue to the next column.

     if (currCol != aCol) {

       currX += cellRect.width;

       continue;

     }

     // Now obtain the properties for our cell.

     PrefillPropertyArray(aRow, currCol);

     nsAutoString properties;

     mView->GetCellProperties(aRow, currCol, properties);

     nsTreeUtils::TokenizeProperties(properties, mScratchArray);

     nsStyleContext* rowContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreerow);

     // We don't want to consider any of the decorations that may be present

     // on the current row, so we have to deflate the rect by the border and 

     // padding and offset its left and top coordinates appropriately. 

     AdjustForBorderPadding(rowContext, cellRect);

     nsStyleContext* cellContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecell);

     NS_NAMED_LITERAL_CSTRING(cell, "cell");

     if (currCol->IsCycler() || cell.Equals(aElement)) {

       // If the current Column is a Cycler, then the Rect is just the cell - the margins. 

       // Similarly, if we're just being asked for the cell rect, provide it. 

       theRect = cellRect;

       nsMargin cellMargin;

       cellContext->StyleMargin()->GetMargin(cellMargin);

       theRect.Deflate(cellMargin);

       break;

     }

     // Since we're not looking for the cell, and since the cell isn't a cycler,

     // we're looking for some subcomponent, and now we need to subtract the 

     // borders and padding of the cell from cellRect so this does not 

     // interfere with our computations.

     AdjustForBorderPadding(cellContext, cellRect);

     nsRefPtr<nsRenderingContext> rc =

       presContext->PresShell()->CreateReferenceRenderingContext();

     // Now we'll start making our way across the cell, starting at the edge of 

     // the cell and proceeding until we hit the right edge. |cellX| is the 

     // working X value that we will increment as we crawl from left to right.

     nscoord cellX = cellRect.x;

     nscoord remainWidth = cellRect.width;

     if (currCol->IsPrimary()) {

       // If the current Column is a Primary, then we need to take into account the indentation

       // and possibly a twisty. 

       // The amount of indentation is the indentation width (|mIndentation|) by the level. 

       int32_t level;

       mView->GetLevel(aRow, &level);

       if (!isRTL)

         cellX += mIndentation * level;

       remainWidth -= mIndentation * level;

       // Find the twisty rect by computing its size. 

       nsRect imageRect;

       nsRect twistyRect(cellRect);

       nsStyleContext* twistyContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreetwisty);

       GetTwistyRect(aRow, currCol, imageRect, twistyRect, presContext,

                     *rc, twistyContext);

       if (NS_LITERAL_CSTRING("twisty").Equals(aElement)) {

         // If we're looking for the twisty Rect, just return the size

         theRect = twistyRect;

         break;

       }

       // Now we need to add in the margins of the twisty element, so that we 

       // can find the offset of the next element in the cell. 

       nsMargin twistyMargin;

       twistyContext->StyleMargin()->GetMargin(twistyMargin);

       twistyRect.Inflate(twistyMargin);

       // Adjust our working X value with the twisty width (image size, margins,

       // borders, padding.

       if (!isRTL)

         cellX += twistyRect.width;

     }

     // Cell Image

     nsStyleContext* imageContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreeimage);

     nsRect imageSize = GetImageSize(aRow, currCol, false, imageContext);

     if (NS_LITERAL_CSTRING("image").Equals(aElement)) {

       theRect = imageSize;

       theRect.x = cellX;

       theRect.y = cellRect.y;

       break;

     }

     // Add in the margins of the cell image.

     nsMargin imageMargin;

     imageContext->StyleMargin()->GetMargin(imageMargin);

     imageSize.Inflate(imageMargin);

     // Increment cellX by the image width

     if (!isRTL)

       cellX += imageSize.width;

     // Cell Text 

     nsAutoString cellText;

     mView->GetCellText(aRow, currCol, cellText);

     // We're going to measure this text so we need to ensure bidi is enabled if

     // necessary

     CheckTextForBidi(cellText);

     // Create a scratch rect to represent the text rectangle, with the current 

     // X and Y coords, and a guess at the width and height. The width is the 

     // remaining width we have left to traverse in the cell, which will be the

     // widest possible value for the text rect, and the row height. 

     nsRect textRect(cellX, cellRect.y, remainWidth, cellRect.height);

     // Measure the width of the text. If the width of the text is greater than 

     // the remaining width available, then we just assume that the text has 

     // been cropped and use the remaining rect as the text Rect. Otherwise,

     // we add in borders and padding to the text dimension and give that back. 

     nsStyleContext* textContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecelltext);

     nsRefPtr<nsFontMetrics> fm;

     nsLayoutUtils::GetFontMetricsForStyleContext(textContext,

                                                  getter_AddRefs(fm));

     nscoord height = fm->MaxHeight();

     nsMargin textMargin;

     textContext->StyleMargin()->GetMargin(textMargin);

     textRect.Deflate(textMargin);

     // Center the text. XXX Obey vertical-align style prop?

     if (height < textRect.height) {

       textRect.y += (textRect.height - height) / 2;

       textRect.height = height;

     }

     nsMargin bp(0,0,0,0);

     GetBorderPadding(textContext, bp);

     textRect.height += bp.top + bp.bottom;

     rc->SetFont(fm);

     AdjustForCellText(cellText, aRow, currCol, *rc, textRect);

     theRect = textRect;

   }

   if (isRTL)

     theRect.x = mInnerBox.width - theRect.x - theRect.width;

   *aX = nsPresContext::AppUnitsToIntCSSPixels(theRect.x);

   *aY = nsPresContext::AppUnitsToIntCSSPixels(theRect.y);

   *aWidth = nsPresContext::AppUnitsToIntCSSPixels(theRect.width);

   *aHeight = nsPresContext::AppUnitsToIntCSSPixels(theRect.height);

   return NS_OK;

 }

 int32_t

 nsTreeBodyFrame::GetRowAt(int32_t aX, int32_t aY)

 {

   // Now just mod by our total inner box height and add to our top row index.

   int32_t row = (aY/mRowHeight)+mTopRowIndex;

   // Check if the coordinates are below our visible space (or within our visible

   // space but below any row).

   if (row > mTopRowIndex + mPageLength || row >= mRowCount)

     return -1;

   return row;

 }

 void

 nsTreeBodyFrame::CheckTextForBidi(nsAutoString& aText)

 {

   // We could check to see whether the prescontext already has bidi enabled,

   // but usually it won't, so it's probably faster to avoid the call to

   // GetPresContext() when it's not needed.

   if (HasRTLChars(aText)) {

     PresContext()->SetBidiEnabled();

   }

 }

 void

 nsTreeBodyFrame::AdjustForCellText(nsAutoString& aText,

                                    int32_t aRowIndex,  nsTreeColumn* aColumn,

                                    nsRenderingContext& aRenderingContext,

                                    nsRect& aTextRect)

 {

   NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");

   nscoord width =

     nsLayoutUtils::GetStringWidth(this, &aRenderingContext, aText.get(), aText.Length());

   nscoord maxWidth = aTextRect.width;

   if (aColumn->Overflow()) {

     DebugOnly<nsresult> rv;

     nsTreeColumn* nextColumn = aColumn->GetNext();

     while (nextColumn && width > maxWidth) {

       while (nextColumn) {

         nscoord width;

         rv = nextColumn->GetWidthInTwips(this, &width);

         NS_ASSERTION(NS_SUCCEEDED(rv), "nextColumn is invalid");

         if (width != 0)

           break;

         nextColumn = nextColumn->GetNext();

       }

       if (nextColumn) {

         nsAutoString nextText;

         mView->GetCellText(aRowIndex, nextColumn, nextText);

         // We don't measure or draw this text so no need to check it for

         // bidi-ness

         if (nextText.Length() == 0) {

           nscoord width;

           rv = nextColumn->GetWidthInTwips(this, &width);

           NS_ASSERTION(NS_SUCCEEDED(rv), "nextColumn is invalid");

           maxWidth += width;

           nextColumn = nextColumn->GetNext();

         }

         else {

           nextColumn = nullptr;

         }

       }

     }

   }

   if (width > maxWidth) {

     // See if the width is even smaller than the ellipsis

     // If so, clear the text completely.

     const nsDependentString& kEllipsis = nsContentUtils::GetLocalizedEllipsis();

     aRenderingContext.SetTextRunRTL(false);

     nscoord ellipsisWidth = aRenderingContext.GetWidth(kEllipsis);

     width = maxWidth;

     if (ellipsisWidth > width)

       aText.SetLength(0);

     else if (ellipsisWidth == width)

       aText.Assign(kEllipsis);

     else {

       // We will be drawing an ellipsis, thank you very much.

       // Subtract out the required width of the ellipsis.

       // This is the total remaining width we have to play with.

       width -= ellipsisWidth;

       // Now we crop.

       switch (aColumn->GetCropStyle()) {

         default:

         case 0: {

           // Crop right.

           nscoord cwidth;

           nscoord twidth = 0;

           uint32_t length = aText.Length();

           uint32_t i;

           for (i = 0; i < length; ++i) {

             char16_t ch = aText[i];

             // XXX this is horrible and doesn't handle clusters

             cwidth = aRenderingContext.GetWidth(ch);

             if (twidth + cwidth > width)

               break;

             twidth += cwidth;

           }

           aText.Truncate(i);

           aText.Append(kEllipsis);

         }

         break;

         case 2: {

           // Crop left.

           nscoord cwidth;

           nscoord twidth = 0;

           int32_t length = aText.Length();

           int32_t i;

           for (i=length-1; i >= 0; --i) {

             char16_t ch = aText[i];

             cwidth = aRenderingContext.GetWidth(ch);

             if (twidth + cwidth > width)

               break;

             twidth += cwidth;

           }

           nsAutoString copy;

           aText.Right(copy, length-1-i);

           aText.Assign(kEllipsis);

           aText += copy;

         }

         break;

         case 1:

         {

           // Crop center.

           nsAutoString leftStr, rightStr;

           nscoord cwidth, twidth = 0;

           int32_t length = aText.Length();

           int32_t rightPos = length - 1;

           for (int32_t leftPos = 0; leftPos < rightPos; ++leftPos) {

             char16_t ch = aText[leftPos];

             cwidth = aRenderingContext.GetWidth(ch);

             twidth += cwidth;

             if (twidth > width)

               break;

             leftStr.Append(ch);

             ch = aText[rightPos];

             cwidth = aRenderingContext.GetWidth(ch);

             twidth += cwidth;

             if (twidth > width)

               break;

             rightStr.Insert(ch, 0);

             --rightPos;

           }

           aText = leftStr;

           aText.Append(kEllipsis);

           aText += rightStr;

         }

         break;

       }

     }

     width = nsLayoutUtils::GetStringWidth(this, &aRenderingContext, aText.get(), aText.Length());

   }

   switch (aColumn->GetTextAlignment()) {

     case NS_STYLE_TEXT_ALIGN_RIGHT: {

       aTextRect.x += aTextRect.width - width;

     }

     break;

     case NS_STYLE_TEXT_ALIGN_CENTER: {

       aTextRect.x += (aTextRect.width - width) / 2;

     }

     break;

   }

   aTextRect.width = width;

 }

 nsIAtom*

 nsTreeBodyFrame::GetItemWithinCellAt(nscoord aX, const nsRect& aCellRect, 

                                      int32_t aRowIndex,

                                      nsTreeColumn* aColumn)

 {

   NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");

   // Obtain the properties for our cell.

   PrefillPropertyArray(aRowIndex, aColumn);

   nsAutoString properties;

   mView->GetCellProperties(aRowIndex, aColumn, properties);

   nsTreeUtils::TokenizeProperties(properties, mScratchArray);

   // Resolve style for the cell.

   nsStyleContext* cellContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecell);

   // Obtain the margins for the cell and then deflate our rect by that 

   // amount.  The cell is assumed to be contained within the deflated rect.

   nsRect cellRect(aCellRect);

   nsMargin cellMargin;

   cellContext->StyleMargin()->GetMargin(cellMargin);

   cellRect.Deflate(cellMargin);

   // Adjust the rect for its border and padding.

   AdjustForBorderPadding(cellContext, cellRect);

   if (aX < cellRect.x || aX >= cellRect.x + cellRect.width) {

     // The user clicked within the cell's margins/borders/padding.  This constitutes a click on the cell.

     return nsCSSAnonBoxes::moztreecell;

   }

   nscoord currX = cellRect.x;

   nscoord remainingWidth = cellRect.width;

   // Handle right alignment hit testing.

   bool isRTL = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;

   nsPresContext* presContext = PresContext();

   nsRefPtr<nsRenderingContext> rc =

     presContext->PresShell()->CreateReferenceRenderingContext();

   if (aColumn->IsPrimary()) {

     // If we're the primary column, we have indentation and a twisty.

     int32_t level;

     mView->GetLevel(aRowIndex, &level);

     if (!isRTL)

       currX += mIndentation*level;

     remainingWidth -= mIndentation*level;

     if ((isRTL && aX > currX + remainingWidth) ||

         (!isRTL && aX < currX)) {

       // The user clicked within the indentation.

       return nsCSSAnonBoxes::moztreecell;

     }

     // Always leave space for the twisty.

     nsRect twistyRect(currX, cellRect.y, remainingWidth, cellRect.height);

     bool hasTwisty = false;

     bool isContainer = false;

     mView->IsContainer(aRowIndex, &isContainer);

     if (isContainer) {

       bool isContainerEmpty = false;

       mView->IsContainerEmpty(aRowIndex, &isContainerEmpty);

       if (!isContainerEmpty)

         hasTwisty = true;

     }

     // Resolve style for the twisty.

     nsStyleContext* twistyContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreetwisty);

     nsRect imageSize;

     GetTwistyRect(aRowIndex, aColumn, imageSize, twistyRect, presContext,

                   *rc, twistyContext);

     // We will treat a click as hitting the twisty if it happens on the margins, borders, padding,

     // or content of the twisty object.  By allowing a "slop" into the margin, we make it a little

     // bit easier for a user to hit the twisty.  (We don't want to be too picky here.)

     nsMargin twistyMargin;

     twistyContext->StyleMargin()->GetMargin(twistyMargin);

     twistyRect.Inflate(twistyMargin);

     if (isRTL)

       twistyRect.x = currX + remainingWidth - twistyRect.width;

     // Now we test to see if aX is actually within the twistyRect.  If it is, and if the item should

     // have a twisty, then we return "twisty".  If it is within the rect but we shouldn't have a twisty,

     // then we return "cell".

     if (aX >= twistyRect.x && aX < twistyRect.x + twistyRect.width) {

       if (hasTwisty)

         return nsCSSAnonBoxes::moztreetwisty;

       else

         return nsCSSAnonBoxes::moztreecell;

     }

     if (!isRTL)

       currX += twistyRect.width;

     remainingWidth -= twistyRect.width;    

   }

   // Now test to see if the user hit the icon for the cell.

   nsRect iconRect(currX, cellRect.y, remainingWidth, cellRect.height);

   // Resolve style for the image.

   nsStyleContext* imageContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreeimage);

   nsRect iconSize = GetImageSize(aRowIndex, aColumn, false, imageContext);

   nsMargin imageMargin;

   imageContext->StyleMargin()->GetMargin(imageMargin);

   iconSize.Inflate(imageMargin);

   iconRect.width = iconSize.width;

   if (isRTL)

     iconRect.x = currX + remainingWidth - iconRect.width;

   if (aX >= iconRect.x && aX < iconRect.x + iconRect.width) {

     // The user clicked on the image.

     return nsCSSAnonBoxes::moztreeimage;

   }

   if (!isRTL)

     currX += iconRect.width;

   remainingWidth -= iconRect.width;    

   nsAutoString cellText;

   mView->GetCellText(aRowIndex, aColumn, cellText);

   // We're going to measure this text so we need to ensure bidi is enabled if

   // necessary

   CheckTextForBidi(cellText);

   nsRect textRect(currX, cellRect.y, remainingWidth, cellRect.height);

   nsStyleContext* textContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecelltext);

   nsMargin textMargin;

   textContext->StyleMargin()->GetMargin(textMargin);

   textRect.Deflate(textMargin);

   AdjustForBorderPadding(textContext, textRect);

   nsRefPtr<nsFontMetrics> fm;

   nsLayoutUtils::GetFontMetricsForStyleContext(textContext,

                                                getter_AddRefs(fm));

   rc->SetFont(fm);

   AdjustForCellText(cellText, aRowIndex, aColumn, *rc, textRect);

   if (aX >= textRect.x && aX < textRect.x + textRect.width)

     return nsCSSAnonBoxes::moztreecelltext;

   else

     return nsCSSAnonBoxes::moztreecell;

 }

 void

 nsTreeBodyFrame::GetCellAt(nscoord aX, nscoord aY, int32_t* aRow,

                            nsTreeColumn** aCol, nsIAtom** aChildElt)

 {

   *aCol = nullptr;

   *aChildElt = nullptr;

   *aRow = GetRowAt(aX, aY);

   if (*aRow < 0)

     return;

   // Determine the column hit.

   for (nsTreeColumn* currCol = mColumns->GetFirstColumn(); currCol; 

        currCol = currCol->GetNext()) {

     nsRect cellRect;

     nsresult rv = currCol->GetRect(this,

                                    mInnerBox.y +

                                          mRowHeight * (*aRow - mTopRowIndex),

                                    mRowHeight,

                                    &cellRect);

     if (NS_FAILED(rv)) {

       NS_NOTREACHED("column has no frame");

       continue;

     }

     if (!OffsetForHorzScroll(cellRect, false))

       continue;

     if (aX >= cellRect.x && aX < cellRect.x + cellRect.width) {

       // We know the column hit now.

       *aCol = currCol;

       if (currCol->IsCycler())

         // Cyclers contain only images.  Fill this in immediately and return.

         *aChildElt = nsCSSAnonBoxes::moztreeimage;

       else

         *aChildElt = GetItemWithinCellAt(aX, cellRect, *aRow, currCol);

       break;

     }

   }

 }

 nsresult

 nsTreeBodyFrame::GetCellWidth(int32_t aRow, nsTreeColumn* aCol,

                               nsRenderingContext* aRenderingContext,

                               nscoord& aDesiredSize, nscoord& aCurrentSize)

 {

   NS_PRECONDITION(aCol, "aCol must not be null");

   NS_PRECONDITION(aRenderingContext, "aRenderingContext must not be null");

   // The rect for the current cell.

   nscoord colWidth;

   nsresult rv = aCol->GetWidthInTwips(this, &colWidth);

   NS_ENSURE_SUCCESS(rv, rv);

   nsRect cellRect(0, 0, colWidth, mRowHeight);

   int32_t overflow = cellRect.x+cellRect.width-(mInnerBox.x+mInnerBox.width);

   if (overflow > 0)

     cellRect.width -= overflow;

   // Adjust borders and padding for the cell.

   nsStyleContext* cellContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecell);

   nsMargin bp(0,0,0,0);

   GetBorderPadding(cellContext, bp);

   aCurrentSize = cellRect.width;

   aDesiredSize = bp.left + bp.right;

   if (aCol->IsPrimary()) {

     // If the current Column is a Primary, then we need to take into account 

     // the indentation and possibly a twisty. 

     // The amount of indentation is the indentation width (|mIndentation|) by the level.

     int32_t level;

     mView->GetLevel(aRow, &level);

     aDesiredSize += mIndentation * level;

     // Find the twisty rect by computing its size.

     nsStyleContext* twistyContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreetwisty);

     nsRect imageSize;

     nsRect twistyRect(cellRect);

     GetTwistyRect(aRow, aCol, imageSize, twistyRect, PresContext(),

                   *aRenderingContext, twistyContext);

     // Add in the margins of the twisty element.

     nsMargin twistyMargin;

     twistyContext->StyleMargin()->GetMargin(twistyMargin);

     twistyRect.Inflate(twistyMargin);

     aDesiredSize += twistyRect.width;

   }

   nsStyleContext* imageContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreeimage);

   // Account for the width of the cell image.

   nsRect imageSize = GetImageSize(aRow, aCol, false, imageContext);

   // Add in the margins of the cell image.

   nsMargin imageMargin;

   imageContext->StyleMargin()->GetMargin(imageMargin);

   imageSize.Inflate(imageMargin);

   aDesiredSize += imageSize.width;

   // Get the cell text.

   nsAutoString cellText;

   mView->GetCellText(aRow, aCol, cellText);

   // We're going to measure this text so we need to ensure bidi is enabled if

   // necessary

   CheckTextForBidi(cellText);

   nsStyleContext* textContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecelltext);

   // Get the borders and padding for the text.

   GetBorderPadding(textContext, bp);

   nsRefPtr<nsFontMetrics> fm;

   nsLayoutUtils::GetFontMetricsForStyleContext(textContext,

                                                getter_AddRefs(fm));

   aRenderingContext->SetFont(fm);

   // Get the width of the text itself

   nscoord width =

     nsLayoutUtils::GetStringWidth(this, aRenderingContext, cellText.get(), cellText.Length());

   nscoord totalTextWidth = width + bp.left + bp.right;

   aDesiredSize += totalTextWidth;

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::IsCellCropped(int32_t aRow, nsITreeColumn* aCol, bool *_retval)

 {  

   nscoord currentSize, desiredSize;

   nsresult rv;

   nsRefPtr<nsTreeColumn> col = GetColumnImpl(aCol);

   if (!col)

     return NS_ERROR_INVALID_ARG;

   nsRefPtr<nsRenderingContext> rc =

     PresContext()->PresShell()->CreateReferenceRenderingContext();

   rv = GetCellWidth(aRow, col, rc, desiredSize, currentSize);

   NS_ENSURE_SUCCESS(rv, rv);

   *_retval = desiredSize > currentSize;

   return NS_OK;

 }

 void

 nsTreeBodyFrame::MarkDirtyIfSelect()

 {

   nsIContent* baseElement = GetBaseElement();

   if (baseElement && baseElement->Tag() == nsGkAtoms::select &&

       baseElement->IsHTML()) {

     // If we are an intrinsically sized select widget, we may need to

     // resize, if the widest item was removed or a new item was added.

     // XXX optimize this more

     mStringWidth = -1;

     PresContext()->PresShell()->FrameNeedsReflow(this,

                                                  nsIPresShell::eTreeChange,

                                                  NS_FRAME_IS_DIRTY);

   }

 }

 nsresult

 nsTreeBodyFrame::CreateTimer(const LookAndFeel::IntID aID,

                              nsTimerCallbackFunc aFunc, int32_t aType,

                              nsITimer** aTimer)

 {

   // Get the delay from the look and feel service.

   int32_t delay = LookAndFeel::GetInt(aID, 0);

   nsCOMPtr<nsITimer> timer;

   // Create a new timer only if the delay is greater than zero.

   // Zero value means that this feature is completely disabled.

   if (delay > 0) {

     timer = do_CreateInstance("@mozilla.org/timer;1");

     if (timer)

       timer->InitWithFuncCallback(aFunc, this, delay, aType);

   }

   NS_IF_ADDREF(*aTimer = timer);

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::RowCountChanged(int32_t aIndex, int32_t aCount)

 {

   if (aCount == 0 || !mView)

     return NS_OK; // Nothing to do.

 #ifdef ACCESSIBILITY

   if (nsIPresShell::IsAccessibilityActive())

     FireRowCountChangedEvent(aIndex, aCount);

 #endif

   // Adjust our selection.

   nsCOMPtr<nsITreeSelection> sel;

   mView->GetSelection(getter_AddRefs(sel));

   if (sel)

     sel->AdjustSelection(aIndex, aCount);

   if (mUpdateBatchNest)

     return NS_OK;

   mRowCount += aCount;

 #ifdef DEBUG

   int32_t rowCount = mRowCount;

   mView->GetRowCount(&rowCount);

   NS_ASSERTION(rowCount == mRowCount, "row count did not change by the amount suggested, check caller");

 #endif

   int32_t count = Abs(aCount);

   int32_t last = LastVisibleRow();

   if (aIndex >= mTopRowIndex && aIndex <= last)

     InvalidateRange(aIndex, last);

   ScrollParts parts = GetScrollParts();

   if (mTopRowIndex == 0) {    

     // Just update the scrollbar and return.

     if (FullScrollbarsUpdate(false)) {

       MarkDirtyIfSelect();

     }

     return NS_OK;

   }

   bool needsInvalidation = false;

   // Adjust our top row index.

   if (aCount > 0) {

     if (mTopRowIndex > aIndex) {

       // Rows came in above us.  Augment the top row index.

       mTopRowIndex += aCount;

     }

   }

   else if (aCount < 0) {

     if (mTopRowIndex > aIndex+count-1) {

       // No need to invalidate. The remove happened

       // completely above us (offscreen).

       mTopRowIndex -= count;

     }

     else if (mTopRowIndex >= aIndex) {

       // This is a full-blown invalidate.

       if (mTopRowIndex + mPageLength > mRowCount - 1) {

         mTopRowIndex = std::max(0, mRowCount - 1 - mPageLength);

       }

       needsInvalidation = true;

     }

   }

   if (FullScrollbarsUpdate(needsInvalidation)) {

     MarkDirtyIfSelect();

   }

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::BeginUpdateBatch()

 {

   ++mUpdateBatchNest;

   return NS_OK;

 }

 nsresult

 nsTreeBodyFrame::EndUpdateBatch()

 {

   NS_ASSERTION(mUpdateBatchNest > 0, "badly nested update batch");

   if (--mUpdateBatchNest == 0) {

     if (mView) {

       Invalidate();

       int32_t countBeforeUpdate = mRowCount;

       mView->GetRowCount(&mRowCount);

       if (countBeforeUpdate != mRowCount) {

         if (mTopRowIndex + mPageLength > mRowCount - 1) {

           mTopRowIndex = std::max(0, mRowCount - 1 - mPageLength);

         }

         FullScrollbarsUpdate(false);

       }

     }

   }

   return NS_OK;

 }

 void

 nsTreeBodyFrame::PrefillPropertyArray(int32_t aRowIndex, nsTreeColumn* aCol)

 {

   NS_PRECONDITION(!aCol || aCol->GetFrame(), "invalid column passed");

   mScratchArray.Clear();

   // focus

   if (mFocused)

     mScratchArray.AppendElement(nsGkAtoms::focus);

   // sort

   bool sorted = false;

   mView->IsSorted(&sorted);

   if (sorted)

     mScratchArray.AppendElement(nsGkAtoms::sorted);

   // drag session

   if (mSlots && mSlots->mIsDragging)

     mScratchArray.AppendElement(nsGkAtoms::dragSession);

   if (aRowIndex != -1) {

     if (aRowIndex == mMouseOverRow)

       mScratchArray.AppendElement(nsGkAtoms::hover);

     nsCOMPtr<nsITreeSelection> selection;

     mView->GetSelection(getter_AddRefs(selection));

     if (selection) {

       // selected

       bool isSelected;

       selection->IsSelected(aRowIndex, &isSelected);

       if (isSelected)

         mScratchArray.AppendElement(nsGkAtoms::selected);

       // current

       int32_t currentIndex;

       selection->GetCurrentIndex(&currentIndex);

       if (aRowIndex == currentIndex)

         mScratchArray.AppendElement(nsGkAtoms::current);

       // active

       if (aCol) {

         nsCOMPtr<nsITreeColumn> currentColumn;

         selection->GetCurrentColumn(getter_AddRefs(currentColumn));

         if (aCol == currentColumn)

           mScratchArray.AppendElement(nsGkAtoms::active);

       }

     }

     // container or leaf

     bool isContainer = false;

     mView->IsContainer(aRowIndex, &isContainer);

     if (isContainer) {

       mScratchArray.AppendElement(nsGkAtoms::container);

       // open or closed

       bool isOpen = false;

       mView->IsContainerOpen(aRowIndex, &isOpen);

       if (isOpen)

         mScratchArray.AppendElement(nsGkAtoms::open);

       else

         mScratchArray.AppendElement(nsGkAtoms::closed);

     }

     else {

       mScratchArray.AppendElement(nsGkAtoms::leaf);

     }

     // drop orientation

     if (mSlots && mSlots->mDropAllowed && mSlots->mDropRow == aRowIndex) {

       if (mSlots->mDropOrient == nsITreeView::DROP_BEFORE)

         mScratchArray.AppendElement(nsGkAtoms::dropBefore);

       else if (mSlots->mDropOrient == nsITreeView::DROP_ON)

         mScratchArray.AppendElement(nsGkAtoms::dropOn);

       else if (mSlots->mDropOrient == nsITreeView::DROP_AFTER)

         mScratchArray.AppendElement(nsGkAtoms::dropAfter);

     }

     // odd or even

     if (aRowIndex % 2)

       mScratchArray.AppendElement(nsGkAtoms::odd);

     else

       mScratchArray.AppendElement(nsGkAtoms::even);

     nsIContent* baseContent = GetBaseElement();

     if (baseContent && baseContent->HasAttr(kNameSpaceID_None, nsGkAtoms::editing))

       mScratchArray.AppendElement(nsGkAtoms::editing);

     // multiple columns

     if (mColumns->GetColumnAt(1))

       mScratchArray.AppendElement(nsGkAtoms::multicol);

   }

   if (aCol) {

     mScratchArray.AppendElement(aCol->GetAtom());

     if (aCol->IsPrimary())

       mScratchArray.AppendElement(nsGkAtoms::primary);

     if (aCol->GetType() == nsITreeColumn::TYPE_CHECKBOX) {

       mScratchArray.AppendElement(nsGkAtoms::checkbox);

       if (aRowIndex != -1) {

         nsAutoString value;

         mView->GetCellValue(aRowIndex, aCol, value);

         if (value.EqualsLiteral("true"))

           mScratchArray.AppendElement(nsGkAtoms::checked);

       }

     }

     else if (aCol->GetType() == nsITreeColumn::TYPE_PROGRESSMETER) {

       mScratchArray.AppendElement(nsGkAtoms::progressmeter);

       if (aRowIndex != -1) {

         int32_t state;

         mView->GetProgressMode(aRowIndex, aCol, &state);

         if (state == nsITreeView::PROGRESS_NORMAL)

           mScratchArray.AppendElement(nsGkAtoms::progressNormal);

         else if (state == nsITreeView::PROGRESS_UNDETERMINED)

           mScratchArray.AppendElement(nsGkAtoms::progressUndetermined);

       }

     }

     // Read special properties from attributes on the column content node

     if (aCol->mContent->AttrValueIs(kNameSpaceID_None,

                                     nsGkAtoms::insertbefore,

                                     nsGkAtoms::_true, eCaseMatters))

       mScratchArray.AppendElement(nsGkAtoms::insertbefore);

     if (aCol->mContent->AttrValueIs(kNameSpaceID_None,

                                     nsGkAtoms::insertafter,

                                     nsGkAtoms::_true, eCaseMatters))

       mScratchArray.AppendElement(nsGkAtoms::insertafter);

   }

 }

 nsITheme*

 nsTreeBodyFrame::GetTwistyRect(int32_t aRowIndex,

                                nsTreeColumn* aColumn,

                                nsRect& aImageRect,

                                nsRect& aTwistyRect,

                                nsPresContext* aPresContext,

                                nsRenderingContext& aRenderingContext,

                                nsStyleContext* aTwistyContext)

 {

   // The twisty rect extends all the way to the end of the cell.  This is incorrect.  We need to

   // determine the twisty rect's true width.  This is done by examining the style context for

   // a width first.  If it has one, we use that.  If it doesn't, we use the image's natural width.

   // If the image hasn't loaded and if no width is specified, then we just bail. If there is

   // a -moz-appearance involved, adjust the rect by the minimum widget size provided by

   // the theme implementation.

   aImageRect = GetImageSize(aRowIndex, aColumn, true, aTwistyContext);

   if (aImageRect.height > aTwistyRect.height)

     aImageRect.height = aTwistyRect.height;

   if (aImageRect.width > aTwistyRect.width)

     aImageRect.width = aTwistyRect.width;

   else

     aTwistyRect.width = aImageRect.width;

   bool useTheme = false;

   nsITheme *theme = nullptr;

   const nsStyleDisplay* twistyDisplayData = aTwistyContext->StyleDisplay();

   if (twistyDisplayData->mAppearance) {

     theme = aPresContext->GetTheme();

     if (theme && theme->ThemeSupportsWidget(aPresContext, nullptr, twistyDisplayData->mAppearance))

       useTheme = true;

   }

   if (useTheme) {

     nsIntSize minTwistySizePx(0,0);

     bool canOverride = true;

     theme->GetMinimumWidgetSize(&aRenderingContext, this, twistyDisplayData->mAppearance,

                                 &minTwistySizePx, &canOverride);

     // GMWS() returns size in pixels, we need to convert it back to app units

     nsSize minTwistySize;

     minTwistySize.width = aPresContext->DevPixelsToAppUnits(minTwistySizePx.width);

     minTwistySize.height = aPresContext->DevPixelsToAppUnits(minTwistySizePx.height);

     if (aTwistyRect.width < minTwistySize.width || !canOverride)

       aTwistyRect.width = minTwistySize.width;

   }

   return useTheme ? theme : nullptr;

 }

 nsresult

 nsTreeBodyFrame::GetImage(int32_t aRowIndex, nsTreeColumn* aCol, bool aUseContext,

                           nsStyleContext* aStyleContext, bool& aAllowImageRegions, imgIContainer** aResult)

 {

   *aResult = nullptr;

   nsAutoString imageSrc;

   mView->GetImageSrc(aRowIndex, aCol, imageSrc);

   nsRefPtr<imgRequestProxy> styleRequest;

   if (!aUseContext && !imageSrc.IsEmpty()) {

     aAllowImageRegions = false;

   }

   else {

     // Obtain the URL from the style context.

     aAllowImageRegions = true;

     styleRequest = aStyleContext->StyleList()->GetListStyleImage();

     if (!styleRequest)

       return NS_OK;

     nsCOMPtr<nsIURI> uri;

     styleRequest->GetURI(getter_AddRefs(uri));

     nsAutoCString spec;

     uri->GetSpec(spec);

     CopyUTF8toUTF16(spec, imageSrc);

   }

   // Look the image up in our cache.

   nsTreeImageCacheEntry entry;

   if (mImageCache.Get(imageSrc, &entry)) {

     // Find out if the image has loaded.

     uint32_t status;

     imgIRequest *imgReq = entry.request;

     imgReq->GetImageStatus(&status);

     imgReq->GetImage(aResult); // We hand back the image here.  The GetImage call addrefs *aResult.

     bool animated = true; // Assuming animated is the safe option

     // We can only call GetAnimated if we're decoded

     if (*aResult && (status & imgIRequest::STATUS_DECODE_COMPLETE))

       (*aResult)->GetAnimated(&animated);

     if ((!(status & imgIRequest::STATUS_LOAD_COMPLETE)) || animated) {

       // We either aren't done loading, or we're animating. Add our row as a listener for invalidations.

       nsCOMPtr<imgINotificationObserver> obs;

       imgReq->GetNotificationObserver(getter_AddRefs(obs));

       if (obs) {

         static_cast<nsTreeImageListener*> (obs.get())->AddCell(aRowIndex, aCol);

       }

       return NS_OK;

     }

   }

   if (!*aResult) {

     // Create a new nsTreeImageListener object and pass it our row and column

     // information.

     nsTreeImageListener* listener = new nsTreeImageListener(this);

     if (!listener)

       return NS_ERROR_OUT_OF_MEMORY;

     if (!mCreatedListeners.PutEntry(listener)) {

       return NS_ERROR_FAILURE;

     }

     listener->AddCell(aRowIndex, aCol);

     nsCOMPtr<imgINotificationObserver> imgNotificationObserver = listener;

     nsRefPtr<imgRequestProxy> imageRequest;

     if (styleRequest) {

       styleRequest->Clone(imgNotificationObserver, getter_AddRefs(imageRequest));

     } else {

       nsIDocument* doc = mContent->GetDocument();

       if (!doc)

         // The page is currently being torn down.  Why bother.

         return NS_ERROR_FAILURE;

       nsCOMPtr<nsIURI> baseURI = mContent->GetBaseURI();

       nsCOMPtr<nsIURI> srcURI;

       nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(srcURI),

                                                 imageSrc,

                                                 doc,

                                                 baseURI);

       if (!srcURI)

         return NS_ERROR_FAILURE;

       // XXXbz what's the origin principal for this stuff that comes from our

       // view?  I guess we should assume that it's the node's principal...

       if (nsContentUtils::CanLoadImage(srcURI, mContent, doc,

                                        mContent->NodePrincipal())) {

         nsresult rv = nsContentUtils::LoadImage(srcURI,

                                                 doc,

                                                 mContent->NodePrincipal(),

                                                 doc->GetDocumentURI(),

                                                 imgNotificationObserver,

                                                 nsIRequest::LOAD_NORMAL,

                                                 EmptyString(),

                                                 getter_AddRefs(imageRequest));

         NS_ENSURE_SUCCESS(rv, rv);

       }

     }

     listener->UnsuppressInvalidation();

     if (!imageRequest)

       return NS_ERROR_FAILURE;

     // We don't want discarding/decode-on-draw for xul images

     imageRequest->StartDecoding();

     imageRequest->LockImage();

     // In a case it was already cached.

     imageRequest->GetImage(aResult);

     nsTreeImageCacheEntry cacheEntry(imageRequest, imgNotificationObserver);

     mImageCache.Put(imageSrc, cacheEntry);

   }

   return NS_OK;

 }

 nsRect nsTreeBodyFrame::GetImageSize(int32_t aRowIndex, nsTreeColumn* aCol, bool aUseContext,

                                      nsStyleContext* aStyleContext)

 {

   // XXX We should respond to visibility rules for collapsed vs. hidden.

   // This method returns the width of the twisty INCLUDING borders and padding.

   // It first checks the style context for a width.  If none is found, it tries to

   // use the default image width for the twisty.  If no image is found, it defaults

   // to border+padding.

   nsRect r(0,0,0,0);

   nsMargin bp(0,0,0,0);

   GetBorderPadding(aStyleContext, bp);

   r.Inflate(bp);

   // Now r contains our border+padding info.  We now need to get our width and

   // height.

   bool needWidth = false;

   bool needHeight = false;

   // We have to load image even though we already have a size.

   // Don't change this, otherwise things start to go crazy.

   bool useImageRegion = true;

   nsCOMPtr<imgIContainer> image;

   GetImage(aRowIndex, aCol, aUseContext, aStyleContext, useImageRegion, getter_AddRefs(image));

   const nsStylePosition* myPosition = aStyleContext->StylePosition();

   const nsStyleList* myList = aStyleContext->StyleList();

   if (useImageRegion) {

     r.x += myList->mImageRegion.x;

     r.y += myList->mImageRegion.y;

   }

   if (myPosition->mWidth.GetUnit() == eStyleUnit_Coord)  {

     int32_t val = myPosition->mWidth.GetCoordValue();

     r.width += val;

   }

   else if (useImageRegion && myList->mImageRegion.width > 0)

     r.width += myList->mImageRegion.width;

   else 

     needWidth = true;

   if (myPosition->mHeight.GetUnit() == eStyleUnit_Coord)  {

     int32_t val = myPosition->mHeight.GetCoordValue();

     r.height += val;

   }

   else if (useImageRegion && myList->mImageRegion.height > 0)

     r.height += myList->mImageRegion.height;

   else 

     needHeight = true;

   if (image) {

     if (needWidth || needHeight) {

       // Get the natural image size.

       if (needWidth) {

         // Get the size from the image.

         nscoord width;

         image->GetWidth(&width);

         r.width += nsPresContext::CSSPixelsToAppUnits(width); 

       }

       if (needHeight) {

         nscoord height;

         image->GetHeight(&height);

         r.height += nsPresContext::CSSPixelsToAppUnits(height); 

       }

     }

   }

   return r;

 }

 // GetImageDestSize returns the destination size of the image.

 // The width and height do not include borders and padding.

 // The width and height have not been adjusted to fit in the row height

 // or cell width.

 // The width and height reflect the destination size specified in CSS,

 // or the image region specified in CSS, or the natural size of the

 // image.

 // If only the destination width has been specified in CSS, the height is

 // calculated to maintain the aspect ratio of the image.

 // If only the destination height has been specified in CSS, the width is

 // calculated to maintain the aspect ratio of the image.

 nsSize

 nsTreeBodyFrame::GetImageDestSize(nsStyleContext* aStyleContext,

                                   bool useImageRegion,

                                   imgIContainer* image)

 {

   nsSize size(0,0);

   // We need to get the width and height.

   bool needWidth = false;

   bool needHeight = false;

   // Get the style position to see if the CSS has specified the

   // destination width/height.

   const nsStylePosition* myPosition = aStyleContext->StylePosition();

   if (myPosition->mWidth.GetUnit() == eStyleUnit_Coord) {

     // CSS has specified the destination width.

     size.width = myPosition->mWidth.GetCoordValue();

   }

   else {

     // We'll need to get the width of the image/region.

     needWidth = true;

   }

   if (myPosition->mHeight.GetUnit() == eStyleUnit_Coord)  {

     // CSS has specified the destination height.

     size.height = myPosition->mHeight.GetCoordValue();

   }

   else {

     // We'll need to get the height of the image/region.

     needHeight = true;

   }

   if (needWidth || needHeight) {

     // We need to get the size of the image/region.

     nsSize imageSize(0,0);

     const nsStyleList* myList = aStyleContext->StyleList();

     if (useImageRegion && myList->mImageRegion.width > 0) {

       // CSS has specified an image region.

       // Use the width of the image region.

       imageSize.width = myList->mImageRegion.width;

     }

     else if (image) {

       nscoord width;

       image->GetWidth(&width);

       imageSize.width = nsPresContext::CSSPixelsToAppUnits(width);

     }

     if (useImageRegion && myList->mImageRegion.height > 0) {

       // CSS has specified an image region.

       // Use the height of the image region.

       imageSize.height = myList->mImageRegion.height;

     }

     else if (image) {

       nscoord height;

       image->GetHeight(&height);

       imageSize.height = nsPresContext::CSSPixelsToAppUnits(height);

     }

     if (needWidth) {

       if (!needHeight && imageSize.height != 0) {

         // The CSS specified the destination height, but not the destination

         // width. We need to calculate the width so that we maintain the

         // image's aspect ratio.

         size.width = imageSize.width * size.height / imageSize.height;

       }

       else {

         size.width = imageSize.width;

       }

     }

     if (needHeight) {

       if (!needWidth && imageSize.width != 0) {

         // The CSS specified the destination width, but not the destination

         // height. We need to calculate the height so that we maintain the

         // image's aspect ratio.

         size.height = imageSize.height * size.width / imageSize.width;

       }

       else {

         size.height = imageSize.height;

       }

     }

   }

   return size;

 }

 // GetImageSourceRect returns the source rectangle of the image to be

 // displayed.

 // The width and height reflect the image region specified in CSS, or

 // the natural size of the image.

 // The width and height do not include borders and padding.

 // The width and height do not reflect the destination size specified

 // in CSS.

 nsRect

 nsTreeBodyFrame::GetImageSourceRect(nsStyleContext* aStyleContext,

                                     bool useImageRegion,

                                     imgIContainer* image)

 {

   nsRect r(0,0,0,0);

   const nsStyleList* myList = aStyleContext->StyleList();

   if (useImageRegion &&

       (myList->mImageRegion.width > 0 || myList->mImageRegion.height > 0)) {

     // CSS has specified an image region.

     r = myList->mImageRegion;

   }

   else if (image) {

     // Use the actual image size.

     nscoord coord;

     image->GetWidth(&coord);

     r.width = nsPresContext::CSSPixelsToAppUnits(coord);

     image->GetHeight(&coord);

     r.height = nsPresContext::CSSPixelsToAppUnits(coord);

   }

   return r;

 }

 int32_t nsTreeBodyFrame::GetRowHeight()

 {

   // Look up the correct height.  It is equal to the specified height

   // + the specified margins.

   mScratchArray.Clear();

   nsStyleContext* rowContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreerow);

   if (rowContext) {

     const nsStylePosition* myPosition = rowContext->StylePosition();

     nscoord minHeight = 0;

     if (myPosition->mMinHeight.GetUnit() == eStyleUnit_Coord)

       minHeight = myPosition->mMinHeight.GetCoordValue();

     nscoord height = 0;

     if (myPosition->mHeight.GetUnit() == eStyleUnit_Coord)

       height = myPosition->mHeight.GetCoordValue();

     if (height < minHeight)

       height = minHeight;

     if (height > 0) {

       height = nsPresContext::AppUnitsToIntCSSPixels(height);

       height += height % 2;

       height = nsPresContext::CSSPixelsToAppUnits(height);

       // XXX Check box-sizing to determine if border/padding should augment the height

       // Inflate the height by our margins.

       nsRect rowRect(0,0,0,height);

       nsMargin rowMargin;

       rowContext->StyleMargin()->GetMargin(rowMargin);

       rowRect.Inflate(rowMargin);

       height = rowRect.height;

       return height;

     }

   }

   return nsPresContext::CSSPixelsToAppUnits(18); // As good a default as any.

 }

 int32_t nsTreeBodyFrame::GetIndentation()

 {

   // Look up the correct indentation.  It is equal to the specified indentation width.

   mScratchArray.Clear();

   nsStyleContext* indentContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreeindentation);

   if (indentContext) {

     const nsStylePosition* myPosition = indentContext->StylePosition();

     if (myPosition->mWidth.GetUnit() == eStyleUnit_Coord)  {

       nscoord val = myPosition->mWidth.GetCoordValue();

       return val;

     }

   }

   return nsPresContext::CSSPixelsToAppUnits(16); // As good a default as any.

 }

 void nsTreeBodyFrame::CalcInnerBox()

 {

   mInnerBox.SetRect(0, 0, mRect.width, mRect.height);

   AdjustForBorderPadding(mStyleContext, mInnerBox);

 }

 nscoord

 nsTreeBodyFrame::CalcHorzWidth(const ScrollParts& aParts)

 {

   // Compute the adjustment to the last column. This varies depending on the

   // visibility of the columnpicker and the scrollbar.

   if (aParts.mColumnsFrame)

     mAdjustWidth = mRect.width - aParts.mColumnsFrame->GetRect().width;

   else

     mAdjustWidth = 0;

   nscoord width = 0;

   // We calculate this from the scrollable frame, so that it 

   // properly covers all contingencies of what could be 

   // scrollable (columns, body, etc...)

   if (aParts.mColumnsScrollFrame) {

     width = aParts.mColumnsScrollFrame->GetScrollRange().width +

       aParts.mColumnsScrollFrame->GetScrollPortRect().width;

   }

   // If no horz scrolling periphery is present, then just return our width

   if (width == 0)

     width = mRect.width;

   return width;

 }

 nsresult

 nsTreeBodyFrame::GetCursor(const nsPoint& aPoint,

                            nsIFrame::Cursor& aCursor)

 {

   // Check the GetScriptHandlingObject so we don't end up running code when

   // the document is a zombie.

   bool dummy;

   if (mView && GetContent()->GetCurrentDoc()->GetScriptHandlingObject(dummy)) {

     int32_t row;

     nsTreeColumn* col;

     nsIAtom* child;

     GetCellAt(aPoint.x, aPoint.y, &row, &col, &child);

     if (child) {

       // Our scratch array is already prefilled.

       nsStyleContext* childContext = GetPseudoStyleContext(child);

       FillCursorInformationFromStyle(childContext->StyleUserInterface(),

                                      aCursor);

       if (aCursor.mCursor == NS_STYLE_CURSOR_AUTO)

         aCursor.mCursor = NS_STYLE_CURSOR_DEFAULT;

       return NS_OK;

     }

   }

   return nsLeafBoxFrame::GetCursor(aPoint, aCursor);

 }

 static uint32_t GetDropEffect(WidgetGUIEvent* aEvent)

 {

   NS_ASSERTION(aEvent->eventStructType == NS_DRAG_EVENT, "wrong event type");

   WidgetDragEvent* dragEvent = aEvent->AsDragEvent();

   nsContentUtils::SetDataTransferInEvent(dragEvent);

   uint32_t action = 0;

   if (dragEvent->dataTransfer)

     dragEvent->dataTransfer->GetDropEffectInt(&action);

   return action;

 }

 nsresult

 nsTreeBodyFrame::HandleEvent(nsPresContext* aPresContext,

                              WidgetGUIEvent* aEvent,

                              nsEventStatus* aEventStatus)

 {

   if (aEvent->message == NS_MOUSE_ENTER_SYNTH || aEvent->message == NS_MOUSE_MOVE) {

     nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, this);

     int32_t xTwips = pt.x - mInnerBox.x;

     int32_t yTwips = pt.y - mInnerBox.y;

     int32_t newrow = GetRowAt(xTwips, yTwips);

     if (mMouseOverRow != newrow) {

       // redraw the old and the new row

       if (mMouseOverRow != -1)

         InvalidateRow(mMouseOverRow);

       mMouseOverRow = newrow;

       if (mMouseOverRow != -1)

         InvalidateRow(mMouseOverRow);

     }

   }

   else if (aEvent->message == NS_MOUSE_EXIT_SYNTH) {

     if (mMouseOverRow != -1) {

       InvalidateRow(mMouseOverRow);

       mMouseOverRow = -1;

     }

   }

   else if (aEvent->message == NS_DRAGDROP_ENTER) {

     if (!mSlots)

       mSlots = new Slots();

     // Cache several things we'll need throughout the course of our work. These

     // will all get released on a drag exit.

     if (mSlots->mTimer) {

       mSlots->mTimer->Cancel();

       mSlots->mTimer = nullptr;

     }

     // Cache the drag session.

     mSlots->mIsDragging = true;

     mSlots->mDropRow = -1;

     mSlots->mDropOrient = -1;

     mSlots->mDragAction = GetDropEffect(aEvent);

   }

   else if (aEvent->message == NS_DRAGDROP_OVER) {

     // The mouse is hovering over this tree. If we determine things are

     // different from the last time, invalidate the drop feedback at the old

     // position, query the view to see if the current location is droppable,

     // and then invalidate the drop feedback at the new location if it is.

     // The mouse may or may not have changed position from the last time

     // we were called, so optimize out a lot of the extra notifications by

     // checking if anything changed first. For drop feedback we use drop,

     // dropBefore and dropAfter property.

     if (!mView || !mSlots)

       return NS_OK;

     // Save last values, we will need them.

     int32_t lastDropRow = mSlots->mDropRow;

     int16_t lastDropOrient = mSlots->mDropOrient;

 #ifndef XP_MACOSX

     int16_t lastScrollLines = mSlots->mScrollLines;

 #endif

     // Find out the current drag action

     uint32_t lastDragAction = mSlots->mDragAction;

     mSlots->mDragAction = GetDropEffect(aEvent);

     // Compute the row mouse is over and the above/below/on state.

     // Below we'll use this to see if anything changed.

     // Also check if we want to auto-scroll.

     ComputeDropPosition(aEvent, &mSlots->mDropRow, &mSlots->mDropOrient, &mSlots->mScrollLines);

     // While we're here, handle tracking of scrolling during a drag.

     if (mSlots->mScrollLines) {

       if (mSlots->mDropAllowed) {

         // Invalidate primary cell at old location.

         mSlots->mDropAllowed = false;

         InvalidateDropFeedback(lastDropRow, lastDropOrient);

       }

 #ifdef XP_MACOSX

       ScrollByLines(mSlots->mScrollLines);

 #else

       if (!lastScrollLines) {

         // Cancel any previously initialized timer.

         if (mSlots->mTimer) {

           mSlots->mTimer->Cancel();

           mSlots->mTimer = nullptr;

         }

         // Set a timer to trigger the tree scrolling.