mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/layout/xul/tree/nsTreeSelection.cpp

869 строки
22 KiB
C++
Исходник Ответственный История

/* -*- 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 "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 "nsINameSpaceManager.h"
#include "nsGkAtoms.h"
#include "nsAsyncDOMEvent.h"
#include "nsEventDispatcher.h"
#include "nsAutoPtr.h"
#include "nsComponentManagerUtils.h"
// 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_2(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<nsAsyncDOMEvent> event =
new nsAsyncDOMEvent(treeDOMNode,
(aIndex != -1 ? DOMMenuItemActive : DOMMenuItemInactive),
true, false);
return event->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<nsAsyncDOMEvent> event =
new nsAsyncDOMEvent(node, NS_LITERAL_STRING("select"), true, false);
event->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;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку