Source code

Revision control

Other Tools

/* -*- 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 "SelectionState.h"
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc.
#include "mozilla/EditorUtils.h" // for EditorUtils
#include "mozilla/dom/RangeBinding.h"
#include "mozilla/dom/Selection.h" // for Selection
#include "nsAString.h" // for nsAString::Length
#include "nsCycleCollectionParticipant.h"
#include "nsDebug.h" // for NS_WARNING, etc.
#include "nsError.h" // for NS_OK, etc.
#include "nsIContent.h" // for nsIContent
#include "nsISupportsImpl.h" // for nsRange::Release
#include "nsRange.h" // for nsRange
namespace mozilla {
using namespace dom;
/******************************************************************************
* mozilla::SelectionState
*
* Class for recording selection info. Stores selection as collection of
* { {startnode, startoffset} , {endnode, endoffset} } tuples. Can't store
* ranges since dom gravity will possibly change the ranges.
******************************************************************************/
template nsresult RangeUpdater::SelAdjCreateNode(const EditorDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjCreateNode(
const EditorRawDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjInsertNode(const EditorDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjInsertNode(
const EditorRawDOMPoint& aPoint);
SelectionState::SelectionState() : mDirection(eDirNext) {}
void SelectionState::SaveSelection(Selection& aSelection) {
// if we need more items in the array, new them
if (mArray.Length() < aSelection.RangeCount()) {
for (uint32_t i = mArray.Length(); i < aSelection.RangeCount(); i++) {
mArray.AppendElement();
mArray[i] = new RangeItem();
}
} else if (mArray.Length() > aSelection.RangeCount()) {
// else if we have too many, delete them
mArray.TruncateLength(aSelection.RangeCount());
}
// now store the selection ranges
for (uint32_t i = 0; i < aSelection.RangeCount(); i++) {
const nsRange* range = aSelection.GetRangeAt(i);
if (NS_WARN_IF(!range)) {
continue;
}
mArray[i]->StoreRange(*range);
}
mDirection = aSelection.GetDirection();
}
nsresult SelectionState::RestoreSelection(Selection& aSelection) {
// clear out selection
IgnoredErrorResult ignoredError;
aSelection.RemoveAllRanges(ignoredError);
NS_WARNING_ASSERTION(!ignoredError.Failed(),
"Selection::RemoveAllRanges() failed, but ignored");
aSelection.SetDirection(mDirection);
ErrorResult error;
const CopyableAutoTArray<RefPtr<RangeItem>, 10> rangeItems(mArray);
for (const RefPtr<RangeItem>& rangeItem : rangeItems) {
RefPtr<nsRange> range = rangeItem->GetRange();
if (!range) {
NS_WARNING("RangeItem::GetRange() failed");
return NS_ERROR_FAILURE;
}
aSelection.AddRangeAndSelectFramesAndNotifyListeners(*range, error);
if (error.Failed()) {
NS_WARNING(
"Selection::AddRangeAndSelectFramesAndNotifyListeners() failed");
return error.StealNSResult();
}
}
return NS_OK;
}
bool SelectionState::IsCollapsed() const {
if (mArray.Length() != 1) {
return false;
}
RefPtr<nsRange> range = mArray[0]->GetRange();
if (!range) {
NS_WARNING("RangeItem::GetRange() failed");
return false;
}
return range->Collapsed();
}
bool SelectionState::Equals(SelectionState& aOther) const {
if (mArray.Length() != aOther.mArray.Length()) {
return false;
}
if (mArray.IsEmpty()) {
return false; // XXX Why?
}
if (mDirection != aOther.mDirection) {
return false;
}
// XXX Creating nsRanges are really expensive. Why cannot we just check
// the container and offsets??
IgnoredErrorResult ignoredError;
for (size_t i = 0; i < mArray.Length(); i++) {
RefPtr<nsRange> range = mArray[i]->GetRange();
if (!range) {
NS_WARNING("Failed to create a range from the range item");
return false;
}
RefPtr<nsRange> otherRange = aOther.mArray[i]->GetRange();
if (!otherRange) {
NS_WARNING("Failed to create a range from the other's range item");
return false;
}
int16_t compResult = range->CompareBoundaryPoints(
Range_Binding::START_TO_START, *otherRange, ignoredError);
if (ignoredError.Failed()) {
NS_WARNING(
"nsRange::CompareBoundaryPoints(Range_Binding::START_TO_START) "
"failed");
return false;
}
if (compResult) {
return false;
}
compResult = range->CompareBoundaryPoints(Range_Binding::END_TO_END,
*otherRange, ignoredError);
if (ignoredError.Failed()) {
NS_WARNING(
"nsRange::CompareBoundaryPoints(Range_Binding::END_TO_END) failed");
return false;
}
if (compResult) {
return false;
}
}
// if we got here, they are equal
return true;
}
void SelectionState::Clear() {
// free any items in the array
mArray.Clear();
mDirection = eDirNext;
}
bool SelectionState::IsEmpty() const { return mArray.IsEmpty(); }
/******************************************************************************
* mozilla::RangeUpdater
*
* Class for updating nsRanges in response to editor actions.
******************************************************************************/
RangeUpdater::RangeUpdater() : mLocked(false) {}
void RangeUpdater::RegisterRangeItem(RangeItem& aRangeItem) {
if (mArray.Contains(&aRangeItem)) {
NS_ERROR("tried to register an already registered range");
return; // don't register it again. It would get doubly adjusted.
}
mArray.AppendElement(&aRangeItem);
}
void RangeUpdater::DropRangeItem(RangeItem& aRangeItem) {
NS_WARNING_ASSERTION(
mArray.Contains(&aRangeItem),
"aRangeItem is not in the range, but tried to removed from it");
mArray.RemoveElement(&aRangeItem);
}
void RangeUpdater::RegisterSelectionState(SelectionState& aSelectionState) {
for (RefPtr<RangeItem>& rangeItem : aSelectionState.mArray) {
if (NS_WARN_IF(!rangeItem)) {
continue;
}
RegisterRangeItem(*rangeItem);
}
}
void RangeUpdater::DropSelectionState(SelectionState& aSelectionState) {
for (RefPtr<RangeItem>& rangeItem : aSelectionState.mArray) {
if (NS_WARN_IF(!rangeItem)) {
continue;
}
DropRangeItem(*rangeItem);
}
}
// gravity methods:
template <typename PT, typename CT>
nsresult RangeUpdater::SelAdjCreateNode(
const EditorDOMPointBase<PT, CT>& aPoint) {
if (mLocked) {
// lock set by Will/DidReplaceParent, etc...
return NS_OK;
}
if (mArray.IsEmpty()) {
return NS_OK;
}
if (NS_WARN_IF(!aPoint.IsSetAndValid())) {
return NS_ERROR_INVALID_ARG;
}
for (RefPtr<RangeItem>& rangeItem : mArray) {
if (NS_WARN_IF(!rangeItem)) {
return NS_ERROR_FAILURE;
}
if (rangeItem->mStartContainer == aPoint.GetContainer() &&
rangeItem->mStartOffset > aPoint.Offset()) {
rangeItem->mStartOffset++;
}
if (rangeItem->mEndContainer == aPoint.GetContainer() &&
rangeItem->mEndOffset > aPoint.Offset()) {
rangeItem->mEndOffset++;
}
}
return NS_OK;
}
template <typename PT, typename CT>
nsresult RangeUpdater::SelAdjInsertNode(
const EditorDOMPointBase<PT, CT>& aPoint) {
nsresult rv = SelAdjCreateNode(aPoint);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
"RangeUpdater::SelAdjCreateNode() failed");
return rv;
}
void RangeUpdater::SelAdjDeleteNode(nsINode& aNodeToDelete) {
if (mLocked) {
// lock set by Will/DidReplaceParent, etc...
return;
}
if (mArray.IsEmpty()) {
return;
}
EditorRawDOMPoint atNodeToDelete(&aNodeToDelete);
NS_ASSERTION(atNodeToDelete.IsSetAndValid(),
"aNodeToDelete must be an orphan node or this is called "
"during mutation");
// check for range endpoints that are after aNodeToDelete and in the same
// parent
for (RefPtr<RangeItem>& rangeItem : mArray) {
MOZ_ASSERT(rangeItem);
if (rangeItem->mStartContainer == atNodeToDelete.GetContainer() &&
rangeItem->mStartOffset > atNodeToDelete.Offset()) {
rangeItem->mStartOffset--;
}
if (rangeItem->mEndContainer == atNodeToDelete.GetContainer() &&
rangeItem->mEndOffset > atNodeToDelete.Offset()) {
rangeItem->mEndOffset--;
}
// check for range endpoints that are in aNodeToDelete
if (rangeItem->mStartContainer == &aNodeToDelete) {
rangeItem->mStartContainer = atNodeToDelete.GetContainer();
rangeItem->mStartOffset = atNodeToDelete.Offset();
}
if (rangeItem->mEndContainer == &aNodeToDelete) {
rangeItem->mEndContainer = atNodeToDelete.GetContainer();
rangeItem->mEndOffset = atNodeToDelete.Offset();
}
// check for range endpoints that are in descendants of aNodeToDelete
bool updateEndBoundaryToo = false;
if (EditorUtils::IsDescendantOf(*rangeItem->mStartContainer,
aNodeToDelete)) {
updateEndBoundaryToo =
rangeItem->mStartContainer == rangeItem->mEndContainer;
rangeItem->mStartContainer = atNodeToDelete.GetContainer();
rangeItem->mStartOffset = atNodeToDelete.Offset();
}
// avoid having to call IsDescendantOf() for common case of range startnode
// == range endnode.
if (updateEndBoundaryToo ||
EditorUtils::IsDescendantOf(*rangeItem->mEndContainer, aNodeToDelete)) {
rangeItem->mEndContainer = atNodeToDelete.GetContainer();
rangeItem->mEndOffset = atNodeToDelete.Offset();
}
}
}
nsresult RangeUpdater::SelAdjSplitNode(nsIContent& aRightNode,
nsIContent& aNewLeftNode) {
if (mLocked) {
// lock set by Will/DidReplaceParent, etc...
return NS_OK;
}
if (mArray.IsEmpty()) {
return NS_OK;
}
EditorRawDOMPoint atLeftNode(&aNewLeftNode);
nsresult rv = SelAdjInsertNode(atLeftNode);
if (NS_FAILED(rv)) {
NS_WARNING("RangeUpdater::SelAdjInsertNode() failed");
return rv;
}
// If point in the ranges is in left node, change its container to the left
// node. If point in the ranges is in right node, subtract numbers of
// children moved to left node from the offset.
uint32_t lengthOfLeftNode = aNewLeftNode.Length();
for (RefPtr<RangeItem>& rangeItem : mArray) {
if (NS_WARN_IF(!rangeItem)) {
return NS_ERROR_FAILURE;
}
if (rangeItem->mStartContainer == &aRightNode) {
if (rangeItem->mStartOffset > lengthOfLeftNode) {
rangeItem->mStartOffset -= lengthOfLeftNode;
} else {
rangeItem->mStartContainer = &aNewLeftNode;
}
}
if (rangeItem->mEndContainer == &aRightNode) {
if (rangeItem->mEndOffset > lengthOfLeftNode) {
rangeItem->mEndOffset -= lengthOfLeftNode;
} else {
rangeItem->mEndContainer = &aNewLeftNode;
}
}
}
return NS_OK;
}
nsresult RangeUpdater::SelAdjJoinNodes(nsINode& aLeftNode, nsINode& aRightNode,
nsINode& aParent, uint32_t aOffset,
uint32_t aOldLeftNodeLength) {
if (mLocked) {
// lock set by Will/DidReplaceParent, etc...
return NS_OK;
}
if (mArray.IsEmpty()) {
return NS_OK;
}
for (RefPtr<RangeItem>& rangeItem : mArray) {
if (NS_WARN_IF(!rangeItem)) {
return NS_ERROR_FAILURE;
}
if (rangeItem->mStartContainer == &aParent) {
// adjust start point in aParent
if (rangeItem->mStartOffset > aOffset) {
rangeItem->mStartOffset--;
} else if (rangeItem->mStartOffset == aOffset) {
// join keeps right hand node
rangeItem->mStartContainer = &aRightNode;
rangeItem->mStartOffset = aOldLeftNodeLength;
}
} else if (rangeItem->mStartContainer == &aRightNode) {
// adjust start point in aRightNode
rangeItem->mStartOffset += aOldLeftNodeLength;
} else if (rangeItem->mStartContainer == &aLeftNode) {
// adjust start point in aLeftNode
rangeItem->mStartContainer = &aRightNode;
}
if (rangeItem->mEndContainer == &aParent) {
// adjust end point in aParent
if (rangeItem->mEndOffset > aOffset) {
rangeItem->mEndOffset--;
} else if (rangeItem->mEndOffset == aOffset) {
// join keeps right hand node
rangeItem->mEndContainer = &aRightNode;
rangeItem->mEndOffset = aOldLeftNodeLength;
}
} else if (rangeItem->mEndContainer == &aRightNode) {
// adjust end point in aRightNode
rangeItem->mEndOffset += aOldLeftNodeLength;
} else if (rangeItem->mEndContainer == &aLeftNode) {
// adjust end point in aLeftNode
rangeItem->mEndContainer = &aRightNode;
}
}
return NS_OK;
}
void RangeUpdater::SelAdjReplaceText(const Text& aTextNode, uint32_t aOffset,
uint32_t aReplacedLength,
uint32_t aInsertedLength) {
if (mLocked) {
// lock set by Will/DidReplaceParent, etc...
return;
}
// First, adjust selection for insertion because when offset is in the
// replaced range, it's adjusted to aOffset and never modified by the
// insertion if we adjust selection for deletion first.
SelAdjInsertText(aTextNode, aOffset, aInsertedLength);
// Then, adjust selection for deletion.
SelAdjDeleteText(aTextNode, aOffset, aReplacedLength);
}
void RangeUpdater::SelAdjInsertText(const Text& aTextNode, uint32_t aOffset,
uint32_t aInsertedLength) {
if (mLocked) {
// lock set by Will/DidReplaceParent, etc...
return;
}
for (RefPtr<RangeItem>& rangeItem : mArray) {
MOZ_ASSERT(rangeItem);
if (rangeItem->mStartContainer == &aTextNode &&
rangeItem->mStartOffset > aOffset) {
rangeItem->mStartOffset += aInsertedLength;
}
if (rangeItem->mEndContainer == &aTextNode &&
rangeItem->mEndOffset > aOffset) {
rangeItem->mEndOffset += aInsertedLength;
}
}
}
void RangeUpdater::SelAdjDeleteText(const Text& aTextNode, uint32_t aOffset,
uint32_t aDeletedLength) {
if (mLocked) {
// lock set by Will/DidReplaceParent, etc...
return;
}
for (RefPtr<RangeItem>& rangeItem : mArray) {
MOZ_ASSERT(rangeItem);
if (rangeItem->mStartContainer == &aTextNode &&
rangeItem->mStartOffset > aOffset) {
if (rangeItem->mStartOffset >= aDeletedLength) {
rangeItem->mStartOffset -= aDeletedLength;
} else {
rangeItem->mStartOffset = 0;
}
}
if (rangeItem->mEndContainer == &aTextNode &&
rangeItem->mEndOffset > aOffset) {
if (rangeItem->mEndOffset >= aDeletedLength) {
rangeItem->mEndOffset -= aDeletedLength;
} else {
rangeItem->mEndOffset = 0;
}
}
}
}
void RangeUpdater::DidReplaceContainer(const Element& aRemovedElement,
Element& aInsertedElement) {
if (NS_WARN_IF(!mLocked)) {
return;
}
mLocked = false;
for (RefPtr<RangeItem>& rangeItem : mArray) {
if (NS_WARN_IF(!rangeItem)) {
return;
}
if (rangeItem->mStartContainer == &aRemovedElement) {
rangeItem->mStartContainer = &aInsertedElement;
}
if (rangeItem->mEndContainer == &aRemovedElement) {
rangeItem->mEndContainer = &aInsertedElement;
}
}
}
void RangeUpdater::DidRemoveContainer(const Element& aRemovedElement,
nsINode& aRemovedElementContainerNode,
uint32_t aOldOffsetOfRemovedElement,
uint32_t aOldChildCountOfRemovedElement) {
if (NS_WARN_IF(!mLocked)) {
return;
}
mLocked = false;
for (RefPtr<RangeItem>& rangeItem : mArray) {
if (NS_WARN_IF(!rangeItem)) {
return;
}
if (rangeItem->mStartContainer == &aRemovedElement) {
rangeItem->mStartContainer = &aRemovedElementContainerNode;
rangeItem->mStartOffset += aOldOffsetOfRemovedElement;
} else if (rangeItem->mStartContainer == &aRemovedElementContainerNode &&
rangeItem->mStartOffset > aOldOffsetOfRemovedElement) {
rangeItem->mStartOffset += aOldChildCountOfRemovedElement - 1;
}
if (rangeItem->mEndContainer == &aRemovedElement) {
rangeItem->mEndContainer = &aRemovedElementContainerNode;
rangeItem->mEndOffset += aOldOffsetOfRemovedElement;
} else if (rangeItem->mEndContainer == &aRemovedElementContainerNode &&
rangeItem->mEndOffset > aOldOffsetOfRemovedElement) {
rangeItem->mEndOffset += aOldChildCountOfRemovedElement - 1;
}
}
}
void RangeUpdater::DidMoveNode(const nsINode& aOldParent, uint32_t aOldOffset,
const nsINode& aNewParent, uint32_t aNewOffset) {
if (NS_WARN_IF(!mLocked)) {
return;
}
mLocked = false;
for (RefPtr<RangeItem>& rangeItem : mArray) {
if (NS_WARN_IF(!rangeItem)) {
return;
}
// like a delete in aOldParent
if (rangeItem->mStartContainer == &aOldParent &&
rangeItem->mStartOffset > aOldOffset) {
rangeItem->mStartOffset--;
}
if (rangeItem->mEndContainer == &aOldParent &&
rangeItem->mEndOffset > aOldOffset) {
rangeItem->mEndOffset--;
}
// and like an insert in aNewParent
if (rangeItem->mStartContainer == &aNewParent &&
rangeItem->mStartOffset > aNewOffset) {
rangeItem->mStartOffset++;
}
if (rangeItem->mEndContainer == &aNewParent &&
rangeItem->mEndOffset > aNewOffset) {
rangeItem->mEndOffset++;
}
}
}
/******************************************************************************
* mozilla::RangeItem
*
* Helper struct for SelectionState. This stores range endpoints.
******************************************************************************/
NS_IMPL_CYCLE_COLLECTION(RangeItem, mStartContainer, mEndContainer)
NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(RangeItem, AddRef)
NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(RangeItem, Release)
void RangeItem::StoreRange(const nsRange& aRange) {
mStartContainer = aRange.GetStartContainer();
mStartOffset = aRange.StartOffset();
mEndContainer = aRange.GetEndContainer();
mEndOffset = aRange.EndOffset();
}
already_AddRefed<nsRange> RangeItem::GetRange() {
RefPtr<nsRange> range = nsRange::Create(
mStartContainer, mStartOffset, mEndContainer, mEndOffset, IgnoreErrors());
NS_WARNING_ASSERTION(range, "nsRange::Create() failed");
return range.forget();
}
} // namespace mozilla