forked from mirrors/gecko-dev
723 lines
20 KiB
C++
723 lines
20 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/AsyncEventDispatcher.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsTreeSelection.h"
|
|
#include "XULTreeElement.h"
|
|
#include "nsITreeView.h"
|
|
#include "nsString.h"
|
|
#include "nsIContent.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsComponentManagerUtils.h"
|
|
#include "nsTreeColumns.h"
|
|
|
|
using namespace mozilla;
|
|
using dom::XULTreeElement;
|
|
|
|
// 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(XULTreeElement* aTree,
|
|
nsTArray<int32_t>& aRanges) {
|
|
if (aTree) {
|
|
RefPtr<nsXULElement> 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(XULTreeElement* 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)
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTreeSelection)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTreeSelection)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsTreeSelection)
|
|
NS_INTERFACE_MAP_ENTRY(nsITreeSelection)
|
|
NS_INTERFACE_MAP_ENTRY(nsINativeTreeSelection)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMETHODIMP nsTreeSelection::GetTree(XULTreeElement** aTree) {
|
|
NS_IF_ADDREF(*aTree = mTree);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsTreeSelection::SetTree(XULTreeElement* aTree) {
|
|
if (mSelectTimer) {
|
|
mSelectTimer->Cancel();
|
|
mSelectTimer = nullptr;
|
|
}
|
|
|
|
mTree = aTree;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsTreeSelection::GetSingle(bool* aSingle) {
|
|
if (!mTree) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
*aSingle = mTree->AttrValueIs(kNameSpaceID_None, nsGkAtoms::seltype,
|
|
u"single"_ns, eCaseMatters);
|
|
|
|
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();
|
|
|
|
if (!mTree) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
nsIEventTarget* target =
|
|
mTree->OwnerDoc()->EventTargetFor(TaskCategory::Other);
|
|
NS_NewTimerWithFuncCallback(getter_AddRefs(mSelectTimer), SelectCallback,
|
|
this, aMsec, nsITimer::TYPE_ONE_SHOT,
|
|
"nsTreeSelection::SelectCallback", target);
|
|
}
|
|
}
|
|
|
|
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::SelectAll() {
|
|
if (!mTree) return NS_OK;
|
|
|
|
nsCOMPtr<nsITreeView> view = mTree->GetView();
|
|
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.
|
|
NS_ENSURE_STATE(mTree);
|
|
|
|
constexpr auto DOMMenuItemActive = u"DOMMenuItemActive"_ns;
|
|
constexpr auto DOMMenuItemInactive = u"DOMMenuItemInactive"_ns;
|
|
|
|
RefPtr<AsyncEventDispatcher> asyncDispatcher = new AsyncEventDispatcher(
|
|
mTree, (aIndex != -1 ? DOMMenuItemActive : DOMMenuItemInactive),
|
|
CanBubble::eYes, ChromeOnlyDispatch::eNo);
|
|
return asyncDispatcher->PostDOMEvent();
|
|
}
|
|
|
|
#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;
|
|
|
|
RefPtr<AsyncEventDispatcher> asyncDispatcher = new AsyncEventDispatcher(
|
|
mTree, u"select"_ns, CanBubble::eYes, ChromeOnlyDispatch::eNo);
|
|
asyncDispatcher->RunDOMEventWhenSafe();
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsTreeSelection::SelectCallback(nsITimer* aTimer, void* aClosure) {
|
|
RefPtr<nsTreeSelection> self = static_cast<nsTreeSelection*>(aClosure);
|
|
if (self) {
|
|
self->FireOnSelectHandler();
|
|
aTimer->Cancel();
|
|
self->mSelectTimer = nullptr;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
nsresult NS_NewTreeSelection(XULTreeElement* aTree,
|
|
nsITreeSelection** aResult) {
|
|
*aResult = new nsTreeSelection(aTree);
|
|
if (!*aResult) return NS_ERROR_OUT_OF_MEMORY;
|
|
NS_ADDREF(*aResult);
|
|
return NS_OK;
|
|
}
|