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 "nsCOMPtr.h"

 #include "nsTreeSelection.h"

 #include "nsIBoxObject.h"

 #include "nsITreeBoxObject.h"

 #include "nsITreeView.h"

 #include "nsString.h"

 #include "nsIDOMElement.h"

 #include "nsDOMClassInfoID.h"

 #include "nsIContent.h"

 #include "nsNameSpaceManager.h"

 #include "nsGkAtoms.h"

 #include "nsAutoPtr.h"

 #include "nsComponentManagerUtils.h"

 using namespace mozilla;

 // A helper class for managing our ranges of selection.

 struct nsTreeRange

 {

   nsTreeSelection* mSelection;

   nsTreeRange* mPrev;

   nsTreeRange* mNext;

   int32_t mMin;

   int32_t mMax;

   nsTreeRange(nsTreeSelection* aSel, int32_t aSingleVal)

     :mSelection(aSel), mPrev(nullptr), mNext(nullptr), mMin(aSingleVal), mMax(aSingleVal) {}

   nsTreeRange(nsTreeSelection* aSel, int32_t aMin, int32_t aMax) 

     :mSelection(aSel), mPrev(nullptr), mNext(nullptr), mMin(aMin), mMax(aMax) {}

   ~nsTreeRange() { delete mNext; }

   void Connect(nsTreeRange* aPrev = nullptr, nsTreeRange* aNext = nullptr) {

     if (aPrev)

       aPrev->mNext = this;

     else

       mSelection->mFirstRange = this;

     if (aNext)

       aNext->mPrev = this;

     mPrev = aPrev;

     mNext = aNext;

   }

   nsresult RemoveRange(int32_t aStart, int32_t aEnd) {

     // This should so be a loop... sigh...

     // We start past the range to remove, so no more to remove

     if (aEnd < mMin)

       return NS_OK;

     // We are the last range to be affected

     if (aEnd < mMax) {

       if (aStart <= mMin) {

         // Just chop the start of the range off

         mMin = aEnd + 1;

       } else {

         // We need to split the range

         nsTreeRange* range = new nsTreeRange(mSelection, aEnd + 1, mMax);

         if (!range)

           return NS_ERROR_OUT_OF_MEMORY;

         mMax = aStart - 1;

         range->Connect(this, mNext);

       }

       return NS_OK;

     }

     nsTreeRange* next = mNext;

     if (aStart <= mMin) {

       // The remove includes us, remove ourselves from the list

       if (mPrev)

         mPrev->mNext = next;

       else

         mSelection->mFirstRange = next;

       if (next)

         next->mPrev = mPrev;

       mPrev = mNext = nullptr;

       delete this;

     } else if (aStart <= mMax) {

       // Just chop the end of the range off

       mMax = aStart - 1;

     }

     return next ? next->RemoveRange(aStart, aEnd) : NS_OK;

   }

   nsresult Remove(int32_t aIndex) {

     if (aIndex >= mMin && aIndex <= mMax) {

       // We have found the range that contains us.

       if (mMin == mMax) {

         // Delete the whole range.

         if (mPrev)

           mPrev->mNext = mNext;

         if (mNext)

           mNext->mPrev = mPrev;

         nsTreeRange* first = mSelection->mFirstRange;

         if (first == this)

           mSelection->mFirstRange = mNext;

         mNext = mPrev = nullptr;

         delete this;

       }

       else if (aIndex == mMin)

         mMin++;

       else if (aIndex == mMax)

         mMax--;

       else {

         // We have to break this range.

         nsTreeRange* newRange = new nsTreeRange(mSelection, aIndex + 1, mMax);

         if (!newRange)

           return NS_ERROR_OUT_OF_MEMORY;

         newRange->Connect(this, mNext);

         mMax = aIndex - 1;

       }

     }

     else if (mNext)

       return mNext->Remove(aIndex);

     return NS_OK;

   }

   nsresult Add(int32_t aIndex) {

     if (aIndex < mMin) {

       // We have found a spot to insert.

       if (aIndex + 1 == mMin)

         mMin = aIndex;

       else if (mPrev && mPrev->mMax+1 == aIndex)

         mPrev->mMax = aIndex;

       else {

         // We have to create a new range.

         nsTreeRange* newRange = new nsTreeRange(mSelection, aIndex);

         if (!newRange)

           return NS_ERROR_OUT_OF_MEMORY;

         newRange->Connect(mPrev, this);

       }

     }

     else if (mNext)

       mNext->Add(aIndex);

     else {

       // Insert on to the end.

       if (mMax+1 == aIndex)

         mMax = aIndex;

       else {

         // We have to create a new range.

         nsTreeRange* newRange = new nsTreeRange(mSelection, aIndex);

         if (!newRange)

           return NS_ERROR_OUT_OF_MEMORY;

         newRange->Connect(this, nullptr);

       }

     }

     return NS_OK;

   }

   bool Contains(int32_t aIndex) {

     if (aIndex >= mMin && aIndex <= mMax)

       return true;

     if (mNext)

       return mNext->Contains(aIndex);

     return false;

   }

   int32_t Count() {

     int32_t total = mMax - mMin + 1;

     if (mNext)

       total += mNext->Count();

     return total;

   }

   static void CollectRanges(nsTreeRange* aRange, nsTArray<int32_t>& aRanges)

   {

     nsTreeRange* cur = aRange;

     while (cur) {

       aRanges.AppendElement(cur->mMin);

       aRanges.AppendElement(cur->mMax);

       cur = cur->mNext;

     }

   }

   static void InvalidateRanges(nsITreeBoxObject* aTree,

                                nsTArray<int32_t>& aRanges)

   {

     if (aTree) {

       nsCOMPtr<nsITreeBoxObject> tree = aTree;

       for (uint32_t i = 0; i < aRanges.Length(); i += 2) {

         aTree->InvalidateRange(aRanges[i], aRanges[i + 1]);

       }

     }

   }

   void Invalidate() {

     nsTArray<int32_t> ranges;

     CollectRanges(this, ranges);

     InvalidateRanges(mSelection->mTree, ranges);

   }

   void RemoveAllBut(int32_t aIndex) {

     if (aIndex >= mMin && aIndex <= mMax) {

       // Invalidate everything in this list.

       nsTArray<int32_t> ranges;

       CollectRanges(mSelection->mFirstRange, ranges);

       mMin = aIndex;

       mMax = aIndex;

       nsTreeRange* first = mSelection->mFirstRange;

       if (mPrev)

         mPrev->mNext = mNext;

       if (mNext)

         mNext->mPrev = mPrev;

       mNext = mPrev = nullptr;

       if (first != this) {

         delete mSelection->mFirstRange;

         mSelection->mFirstRange = this;

       }

       InvalidateRanges(mSelection->mTree, ranges);

     }

     else if (mNext)

       mNext->RemoveAllBut(aIndex);

   }

   void Insert(nsTreeRange* aRange) {

     if (mMin >= aRange->mMax)

       aRange->Connect(mPrev, this);

     else if (mNext)

       mNext->Insert(aRange);

     else 

       aRange->Connect(this, nullptr);

   }

 };

 nsTreeSelection::nsTreeSelection(nsITreeBoxObject* aTree)

   : mTree(aTree),

     mSuppressed(false),

     mCurrentIndex(-1),

     mShiftSelectPivot(-1),

     mFirstRange(nullptr)

 {

 }

 nsTreeSelection::~nsTreeSelection()

 {

   delete mFirstRange;

   if (mSelectTimer)

     mSelectTimer->Cancel();

 }

 NS_IMPL_CYCLE_COLLECTION(nsTreeSelection, mTree, mCurrentColumn)

 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTreeSelection)

 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTreeSelection)

 DOMCI_DATA(TreeSelection, nsTreeSelection)

 // QueryInterface implementation for nsBoxObject

 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsTreeSelection)

   NS_INTERFACE_MAP_ENTRY(nsITreeSelection)

   NS_INTERFACE_MAP_ENTRY(nsINativeTreeSelection)

   NS_INTERFACE_MAP_ENTRY(nsISupports)

   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(TreeSelection)

 NS_INTERFACE_MAP_END

 NS_IMETHODIMP nsTreeSelection::GetTree(nsITreeBoxObject * *aTree)

 {

   NS_IF_ADDREF(*aTree = mTree);

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::SetTree(nsITreeBoxObject * aTree)

 {

   if (mSelectTimer) {

     mSelectTimer->Cancel();

     mSelectTimer = nullptr;

   }

   // Make sure aTree really implements nsITreeBoxObject and nsIBoxObject!

   nsCOMPtr<nsIBoxObject> bo = do_QueryInterface(aTree);

   mTree = do_QueryInterface(bo);

   NS_ENSURE_STATE(mTree == aTree);

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::GetSingle(bool* aSingle)

 {

   if (!mTree)

     return NS_ERROR_NULL_POINTER;

   nsCOMPtr<nsIBoxObject> boxObject = do_QueryInterface(mTree);

   nsCOMPtr<nsIDOMElement> element;

   boxObject->GetElement(getter_AddRefs(element));

   nsCOMPtr<nsIContent> content = do_QueryInterface(element);

   static nsIContent::AttrValuesArray strings[] =

     {&nsGkAtoms::single, &nsGkAtoms::cell, &nsGkAtoms::text, nullptr};

   *aSingle = content->FindAttrValueIn(kNameSpaceID_None,

                                       nsGkAtoms::seltype,

                                       strings, eCaseMatters) >= 0;

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::IsSelected(int32_t aIndex, bool* aResult)

 {

   if (mFirstRange)

     *aResult = mFirstRange->Contains(aIndex);

   else

     *aResult = false;

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::TimedSelect(int32_t aIndex, int32_t aMsec)

 {

   bool suppressSelect = mSuppressed;

   if (aMsec != -1)

     mSuppressed = true;

   nsresult rv = Select(aIndex);

   if (NS_FAILED(rv))

     return rv;

   if (aMsec != -1) {

     mSuppressed = suppressSelect;

     if (!mSuppressed) {

       if (mSelectTimer)

         mSelectTimer->Cancel();

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

       mSelectTimer->InitWithFuncCallback(SelectCallback, this, aMsec, 

                                          nsITimer::TYPE_ONE_SHOT);

     }

   }

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::Select(int32_t aIndex)

 {

   mShiftSelectPivot = -1;

   nsresult rv = SetCurrentIndex(aIndex);

   if (NS_FAILED(rv))

     return rv;

   if (mFirstRange) {

     bool alreadySelected = mFirstRange->Contains(aIndex);

     if (alreadySelected) {

       int32_t count = mFirstRange->Count();

       if (count > 1) {

         // We need to deselect everything but our item.

         mFirstRange->RemoveAllBut(aIndex);

         FireOnSelectHandler();

       }

       return NS_OK;

     }

     else {

       // Clear out our selection.

       mFirstRange->Invalidate();

       delete mFirstRange;

     }

   }

   // Create our new selection.

   mFirstRange = new nsTreeRange(this, aIndex);

   if (!mFirstRange)

     return NS_ERROR_OUT_OF_MEMORY;

   mFirstRange->Invalidate();

   // Fire the select event

   FireOnSelectHandler();

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::ToggleSelect(int32_t aIndex)

 {

   // There are six cases that can occur on a ToggleSelect with our

   // range code.

   // (1) A new range should be made for a selection.

   // (2) A single range is removed from the selection.

   // (3) The item is added to an existing range.

   // (4) The item is removed from an existing range.

   // (5) The addition of the item causes two ranges to be merged.

   // (6) The removal of the item causes two ranges to be split.

   mShiftSelectPivot = -1;

   nsresult rv = SetCurrentIndex(aIndex);

   if (NS_FAILED(rv))

     return rv;

   if (!mFirstRange)

     Select(aIndex);

   else {

     if (!mFirstRange->Contains(aIndex)) {

       bool single;

       rv = GetSingle(&single);

       if (NS_SUCCEEDED(rv) && !single)

         rv = mFirstRange->Add(aIndex);

     }

     else

       rv = mFirstRange->Remove(aIndex);

     if (NS_SUCCEEDED(rv)) {

       if (mTree)

         mTree->InvalidateRow(aIndex);

       FireOnSelectHandler();

     }

   }

   return rv;

 }

 NS_IMETHODIMP nsTreeSelection::RangedSelect(int32_t aStartIndex, int32_t aEndIndex, bool aAugment)

 {

   bool single;

   nsresult rv = GetSingle(&single);

   if (NS_FAILED(rv))

     return rv;

   if ((mFirstRange || (aStartIndex != aEndIndex)) && single)

     return NS_OK;

   if (!aAugment) {

     // Clear our selection.

     if (mFirstRange) {

         mFirstRange->Invalidate();

         delete mFirstRange;

         mFirstRange = nullptr;

     }

   }

   if (aStartIndex == -1) {

     if (mShiftSelectPivot != -1)

       aStartIndex = mShiftSelectPivot;

     else if (mCurrentIndex != -1)

       aStartIndex = mCurrentIndex;

     else

       aStartIndex = aEndIndex;

   }

   mShiftSelectPivot = aStartIndex;

   rv = SetCurrentIndex(aEndIndex);

   if (NS_FAILED(rv))

     return rv;

   int32_t start = aStartIndex < aEndIndex ? aStartIndex : aEndIndex;

   int32_t end = aStartIndex < aEndIndex ? aEndIndex : aStartIndex;

   if (aAugment && mFirstRange) {

     // We need to remove all the items within our selected range from the selection,

     // and then we insert our new range into the list.

     nsresult rv = mFirstRange->RemoveRange(start, end);

     if (NS_FAILED(rv))

       return rv;

   }

   nsTreeRange* range = new nsTreeRange(this, start, end);

   if (!range)

     return NS_ERROR_OUT_OF_MEMORY;

   range->Invalidate();

   if (aAugment && mFirstRange)

     mFirstRange->Insert(range);

   else

     mFirstRange = range;

   FireOnSelectHandler();

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::ClearRange(int32_t aStartIndex, int32_t aEndIndex)

 {

   nsresult rv = SetCurrentIndex(aEndIndex);

   if (NS_FAILED(rv))

     return rv;

   if (mFirstRange) {

     int32_t start = aStartIndex < aEndIndex ? aStartIndex : aEndIndex;

     int32_t end = aStartIndex < aEndIndex ? aEndIndex : aStartIndex;

     mFirstRange->RemoveRange(start, end);

     if (mTree)

       mTree->InvalidateRange(start, end);

   }

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::ClearSelection()

 {

   if (mFirstRange) {

     mFirstRange->Invalidate();

     delete mFirstRange;

     mFirstRange = nullptr;

   }

   mShiftSelectPivot = -1;

   FireOnSelectHandler();

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::InvertSelection()

 {

   return NS_ERROR_NOT_IMPLEMENTED;

 }

 NS_IMETHODIMP nsTreeSelection::SelectAll()

 {

   if (!mTree)

     return NS_OK;

   nsCOMPtr<nsITreeView> view;

   mTree->GetView(getter_AddRefs(view));

   if (!view)

     return NS_OK;

   int32_t rowCount;

   view->GetRowCount(&rowCount);

   bool single;

   nsresult rv = GetSingle(&single);

   if (NS_FAILED(rv))

     return rv;

   if (rowCount == 0 || (rowCount > 1 && single))

     return NS_OK;

   mShiftSelectPivot = -1;

   // Invalidate not necessary when clearing selection, since 

   // we're going to invalidate the world on the SelectAll.

   delete mFirstRange;

   mFirstRange = new nsTreeRange(this, 0, rowCount-1);

   mFirstRange->Invalidate();

   FireOnSelectHandler();

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::GetRangeCount(int32_t* aResult)

 {

   int32_t count = 0;

   nsTreeRange* curr = mFirstRange;

   while (curr) {

     count++;

     curr = curr->mNext;

   }

   *aResult = count;

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::GetRangeAt(int32_t aIndex, int32_t* aMin, int32_t* aMax)

 {

   *aMin = *aMax = -1;

   int32_t i = -1;

   nsTreeRange* curr = mFirstRange;

   while (curr) {

     i++;

     if (i == aIndex) {

       *aMin = curr->mMin;

       *aMax = curr->mMax;

       break;

     }

     curr = curr->mNext;

   }

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::GetCount(int32_t *count)

 {

   if (mFirstRange)

     *count = mFirstRange->Count();

   else // No range available, so there's no selected row.

     *count = 0;

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::GetSelectEventsSuppressed(bool *aSelectEventsSuppressed)

 {

   *aSelectEventsSuppressed = mSuppressed;

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::SetSelectEventsSuppressed(bool aSelectEventsSuppressed)

 {

   mSuppressed = aSelectEventsSuppressed;

   if (!mSuppressed)

     FireOnSelectHandler();

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::GetCurrentIndex(int32_t *aCurrentIndex)

 {

   *aCurrentIndex = mCurrentIndex;

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::SetCurrentIndex(int32_t aIndex)

 {

   if (!mTree) {

     return NS_ERROR_UNEXPECTED;

   }

   if (mCurrentIndex == aIndex) {

     return NS_OK;

   }

   if (mCurrentIndex != -1 && mTree)

     mTree->InvalidateRow(mCurrentIndex);

   mCurrentIndex = aIndex;

   if (!mTree)

     return NS_OK;

   if (aIndex != -1)

     mTree->InvalidateRow(aIndex);

   // Fire DOMMenuItemActive or DOMMenuItemInactive event for tree.

   nsCOMPtr<nsIBoxObject> boxObject = do_QueryInterface(mTree);

   NS_ASSERTION(boxObject, "no box object!");

   if (!boxObject)

     return NS_ERROR_UNEXPECTED;

   nsCOMPtr<nsIDOMElement> treeElt;

   boxObject->GetElement(getter_AddRefs(treeElt));

   nsCOMPtr<nsINode> treeDOMNode(do_QueryInterface(treeElt));

   NS_ENSURE_STATE(treeDOMNode);

   NS_NAMED_LITERAL_STRING(DOMMenuItemActive, "DOMMenuItemActive");

   NS_NAMED_LITERAL_STRING(DOMMenuItemInactive, "DOMMenuItemInactive");

   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =

     new AsyncEventDispatcher(treeDOMNode,

                              (aIndex != -1 ? DOMMenuItemActive :

                                              DOMMenuItemInactive),

                              true, false);

   return asyncDispatcher->PostDOMEvent();

 }

 NS_IMETHODIMP nsTreeSelection::GetCurrentColumn(nsITreeColumn** aCurrentColumn)

 {

   NS_IF_ADDREF(*aCurrentColumn = mCurrentColumn);

   return NS_OK;

 }

 NS_IMETHODIMP nsTreeSelection::SetCurrentColumn(nsITreeColumn* aCurrentColumn)

 {

   if (!mTree) {

     return NS_ERROR_UNEXPECTED;

   }

   if (mCurrentColumn == aCurrentColumn) {

     return NS_OK;

   }

   if (mCurrentColumn) {

     if (mFirstRange)

       mTree->InvalidateCell(mFirstRange->mMin, mCurrentColumn);

     if (mCurrentIndex != -1)

       mTree->InvalidateCell(mCurrentIndex, mCurrentColumn);

   }

   mCurrentColumn = aCurrentColumn;

   if (mCurrentColumn) {

     if (mFirstRange)

       mTree->InvalidateCell(mFirstRange->mMin, mCurrentColumn);

     if (mCurrentIndex != -1)

       mTree->InvalidateCell(mCurrentIndex, mCurrentColumn);

   }

   return NS_OK;

 }

 #define ADD_NEW_RANGE(macro_range, macro_selection, macro_start, macro_end) \

   { \

     int32_t start = macro_start; \

     int32_t end = macro_end; \

     if (start > end) { \

       end = start; \

     } \

     nsTreeRange* macro_new_range = new nsTreeRange(macro_selection, start, end); \

     if (macro_range) \

       macro_range->Insert(macro_new_range); \

     else \

       macro_range = macro_new_range; \

   }

 NS_IMETHODIMP

 nsTreeSelection::AdjustSelection(int32_t aIndex, int32_t aCount)

 {

   NS_ASSERTION(aCount != 0, "adjusting by zero");

   if (!aCount) return NS_OK;

   // adjust mShiftSelectPivot, if necessary

   if ((mShiftSelectPivot != 1) && (aIndex <= mShiftSelectPivot)) {

     // if we are deleting and the delete includes the shift select pivot, reset it

     if (aCount < 0 && (mShiftSelectPivot <= (aIndex -aCount -1))) {

         mShiftSelectPivot = -1;

     }

     else {

         mShiftSelectPivot += aCount;

     }

   }

   // adjust mCurrentIndex, if necessary

   if ((mCurrentIndex != -1) && (aIndex <= mCurrentIndex)) {

     // if we are deleting and the delete includes the current index, reset it

     if (aCount < 0 && (mCurrentIndex <= (aIndex -aCount -1))) {

         mCurrentIndex = -1;

     }

     else {

         mCurrentIndex += aCount;

     }

   }

   // no selection, so nothing to do.

   if (!mFirstRange) return NS_OK;

   bool selChanged = false;

   nsTreeRange* oldFirstRange = mFirstRange;

   nsTreeRange* curr = mFirstRange;

   mFirstRange = nullptr;

   while (curr) {

     if (aCount > 0) {

       // inserting

       if (aIndex > curr->mMax) {

         // adjustment happens after the range, so no change

         ADD_NEW_RANGE(mFirstRange, this, curr->mMin, curr->mMax);

       }

       else if (aIndex <= curr->mMin) {  

         // adjustment happens before the start of the range, so shift down

         ADD_NEW_RANGE(mFirstRange, this, curr->mMin + aCount, curr->mMax + aCount);

         selChanged = true;

       }

       else {

         // adjustment happen inside the range.

         // break apart the range and create two ranges

         ADD_NEW_RANGE(mFirstRange, this, curr->mMin, aIndex - 1);

         ADD_NEW_RANGE(mFirstRange, this, aIndex + aCount, curr->mMax + aCount);

         selChanged = true;

       }

     }

     else {

       // deleting

       if (aIndex > curr->mMax) {

         // adjustment happens after the range, so no change

         ADD_NEW_RANGE(mFirstRange, this, curr->mMin, curr->mMax);

       }

       else {

         // remember, aCount is negative

         selChanged = true;

         int32_t lastIndexOfAdjustment = aIndex - aCount - 1;

         if (aIndex <= curr->mMin) {

           if (lastIndexOfAdjustment < curr->mMin) {

             // adjustment happens before the start of the range, so shift up

             ADD_NEW_RANGE(mFirstRange, this, curr->mMin + aCount, curr->mMax + aCount);

           }

           else if (lastIndexOfAdjustment >= curr->mMax) {

             // adjustment contains the range.  remove the range by not adding it to the newRange

           }

           else {

             // adjustment starts before the range, and ends in the middle of it, so trim the range

             ADD_NEW_RANGE(mFirstRange, this, aIndex, curr->mMax + aCount)

           }

         }

         else if (lastIndexOfAdjustment >= curr->mMax) {

          // adjustment starts in the middle of the current range, and contains the end of the range, so trim the range

          ADD_NEW_RANGE(mFirstRange, this, curr->mMin, aIndex - 1)

         }

         else {

           // range contains the adjustment, so shorten the range

           ADD_NEW_RANGE(mFirstRange, this, curr->mMin, curr->mMax + aCount)

         }

       }

     }

     curr = curr->mNext;

   }

   delete oldFirstRange;

   // Fire the select event

   if (selChanged)

     FireOnSelectHandler();

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTreeSelection::InvalidateSelection()

 {

   if (mFirstRange)

     mFirstRange->Invalidate();

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTreeSelection::GetShiftSelectPivot(int32_t* aIndex)

 {

   *aIndex = mShiftSelectPivot;

   return NS_OK;

 }

 nsresult

 nsTreeSelection::FireOnSelectHandler()

 {

   if (mSuppressed || !mTree)

     return NS_OK;

   nsCOMPtr<nsIBoxObject> boxObject = do_QueryInterface(mTree);

   NS_ASSERTION(boxObject, "no box object!");

   if (!boxObject)

      return NS_ERROR_UNEXPECTED;

   nsCOMPtr<nsIDOMElement> elt;

   boxObject->GetElement(getter_AddRefs(elt));

   NS_ENSURE_STATE(elt);

   nsCOMPtr<nsINode> node(do_QueryInterface(elt));

   NS_ENSURE_STATE(node);

   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =

     new AsyncEventDispatcher(node, NS_LITERAL_STRING("select"), true, false);

   asyncDispatcher->RunDOMEventWhenSafe();

   return NS_OK;

 }

 void

 nsTreeSelection::SelectCallback(nsITimer *aTimer, void *aClosure)

 {

   nsRefPtr<nsTreeSelection> self = static_cast<nsTreeSelection*>(aClosure);

   if (self) {

     self->FireOnSelectHandler();

     aTimer->Cancel();

     self->mSelectTimer = nullptr;

   }

 }

 ///////////////////////////////////////////////////////////////////////////////////

 nsresult

 NS_NewTreeSelection(nsITreeBoxObject* aTree, nsITreeSelection** aResult)

 {

   *aResult = new nsTreeSelection(aTree);

   if (!*aResult)

     return NS_ERROR_OUT_OF_MEMORY;

   NS_ADDREF(*aResult);

   return NS_OK;

 }