2001-09-25 22:53:13 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 14:21:17 +00:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
2001-01-28 20:13:07 +00:00
|
|
|
*
|
2004-04-18 14:21:17 +00:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
2001-01-28 20:13:07 +00:00
|
|
|
*
|
2001-09-25 22:53:13 +00:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
2001-01-28 20:13:07 +00:00
|
|
|
*
|
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 14:21:17 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-25 22:53:13 +00:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
2001-01-28 20:13:07 +00:00
|
|
|
*
|
2001-09-25 22:53:13 +00:00
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 14:21:17 +00:00
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
2001-09-25 22:53:13 +00:00
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-18 14:21:17 +00:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-25 22:53:13 +00:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-18 14:21:17 +00:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-25 22:53:13 +00:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
#include "nsSelectionState.h"
|
|
|
|
#include "nsIDOMCharacterData.h"
|
|
|
|
#include "nsIDOMNode.h"
|
2012-01-10 14:19:54 +00:00
|
|
|
#include "nsRange.h"
|
2001-01-28 20:13:07 +00:00
|
|
|
#include "nsISelection.h"
|
|
|
|
#include "nsEditor.h"
|
2002-12-22 01:51:14 +00:00
|
|
|
#include "nsEditorUtils.h"
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* class for recording selection info. stores selection as collection of
|
2005-11-25 21:57:13 +00:00
|
|
|
* { {startnode, startoffset} , {endnode, endoffset} } tuples. Can't store
|
2001-01-28 20:13:07 +00:00
|
|
|
* ranges since dom gravity will possibly change the ranges.
|
|
|
|
*/
|
|
|
|
nsSelectionState::nsSelectionState() : mArray(){}
|
|
|
|
|
|
|
|
nsSelectionState::~nsSelectionState()
|
|
|
|
{
|
|
|
|
MakeEmpty();
|
|
|
|
}
|
|
|
|
|
2009-05-09 04:59:25 +00:00
|
|
|
void
|
|
|
|
nsSelectionState::DoTraverse(nsCycleCollectionTraversalCallback &cb)
|
|
|
|
{
|
|
|
|
for (PRUint32 i = 0, iEnd = mArray.Length(); i < iEnd; ++i)
|
|
|
|
{
|
|
|
|
nsRangeStore &item = mArray[i];
|
|
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb,
|
|
|
|
"selection state mArray[i].startNode");
|
|
|
|
cb.NoteXPCOMChild(item.startNode);
|
|
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb,
|
|
|
|
"selection state mArray[i].endNode");
|
|
|
|
cb.NoteXPCOMChild(item.endNode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-01-28 20:13:07 +00:00
|
|
|
nsresult
|
|
|
|
nsSelectionState::SaveSelection(nsISelection *aSel)
|
|
|
|
{
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aSel, NS_ERROR_NULL_POINTER);
|
2009-06-16 12:38:51 +00:00
|
|
|
PRInt32 i,rangeCount, arrayCount = mArray.Length();
|
2001-01-28 20:13:07 +00:00
|
|
|
aSel->GetRangeCount(&rangeCount);
|
|
|
|
|
2009-06-16 12:38:51 +00:00
|
|
|
// if we need more items in the array, new them
|
|
|
|
if (arrayCount<rangeCount)
|
|
|
|
{
|
|
|
|
PRInt32 count = rangeCount-arrayCount;
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
|
|
|
mArray.AppendElement();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// else if we have too many, delete them
|
|
|
|
else if (arrayCount>rangeCount)
|
|
|
|
{
|
|
|
|
for (i = arrayCount-1; i >= rangeCount; i--)
|
|
|
|
{
|
|
|
|
mArray.RemoveElementAt(i);
|
|
|
|
}
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
// now store the selection ranges
|
2003-06-30 19:10:53 +00:00
|
|
|
nsresult res = NS_OK;
|
2001-01-28 20:13:07 +00:00
|
|
|
for (i=0; i<rangeCount; i++)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDOMRange> range;
|
|
|
|
res = aSel->GetRangeAt(i, getter_AddRefs(range));
|
2009-04-22 08:43:15 +00:00
|
|
|
mArray[i].StoreRange(range);
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsSelectionState::RestoreSelection(nsISelection *aSel)
|
|
|
|
{
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aSel, NS_ERROR_NULL_POINTER);
|
2003-07-18 14:12:51 +00:00
|
|
|
nsresult res;
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, arrayCount = mArray.Length();
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
// clear out selection
|
|
|
|
aSel->RemoveAllRanges();
|
|
|
|
|
|
|
|
// set the selection ranges anew
|
|
|
|
for (i=0; i<arrayCount; i++)
|
|
|
|
{
|
2012-01-10 14:19:54 +00:00
|
|
|
nsRefPtr<nsRange> range;
|
|
|
|
mArray[i].GetRange(getter_AddRefs(range));
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(range, NS_ERROR_UNEXPECTED);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
res = aSel->AddRange(range);
|
|
|
|
if(NS_FAILED(res)) return res;
|
|
|
|
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool
|
2001-01-28 20:13:07 +00:00
|
|
|
nsSelectionState::IsCollapsed()
|
|
|
|
{
|
2011-10-17 14:59:28 +00:00
|
|
|
if (1 != mArray.Length()) return false;
|
2012-01-10 14:19:54 +00:00
|
|
|
nsRefPtr<nsRange> range;
|
|
|
|
mArray[0].GetRange(getter_AddRefs(range));
|
2011-10-17 14:59:28 +00:00
|
|
|
NS_ENSURE_TRUE(range, false);
|
2011-09-29 06:19:26 +00:00
|
|
|
bool bIsCollapsed = false;
|
2001-01-28 20:13:07 +00:00
|
|
|
range->GetCollapsed(&bIsCollapsed);
|
|
|
|
return bIsCollapsed;
|
|
|
|
}
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool
|
2001-01-28 20:13:07 +00:00
|
|
|
nsSelectionState::IsEqual(nsSelectionState *aSelState)
|
|
|
|
{
|
2011-10-17 14:59:28 +00:00
|
|
|
NS_ENSURE_TRUE(aSelState, false);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, myCount = mArray.Length(), itsCount = aSelState->mArray.Length();
|
2011-10-17 14:59:28 +00:00
|
|
|
if (myCount != itsCount) return false;
|
|
|
|
if (myCount < 1) return false;
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
for (i=0; i<myCount; i++)
|
|
|
|
{
|
2012-01-10 14:19:54 +00:00
|
|
|
nsRefPtr<nsRange> myRange, itsRange;
|
|
|
|
mArray[i].GetRange(getter_AddRefs(myRange));
|
|
|
|
aSelState->mArray[i].GetRange(getter_AddRefs(itsRange));
|
2011-10-17 14:59:28 +00:00
|
|
|
NS_ENSURE_TRUE(myRange && itsRange, false);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
2003-01-14 23:05:52 +00:00
|
|
|
PRInt16 compResult;
|
2010-08-06 02:13:07 +00:00
|
|
|
nsresult rv;
|
|
|
|
rv = myRange->CompareBoundaryPoints(nsIDOMRange::START_TO_START, itsRange, &compResult);
|
2011-10-17 14:59:28 +00:00
|
|
|
if (NS_FAILED(rv) || compResult) return false;
|
2010-08-06 02:13:07 +00:00
|
|
|
rv = myRange->CompareBoundaryPoints(nsIDOMRange::END_TO_END, itsRange, &compResult);
|
2011-10-17 14:59:28 +00:00
|
|
|
if (NS_FAILED(rv) || compResult) return false;
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
// if we got here, they are equal
|
2011-10-17 14:59:28 +00:00
|
|
|
return true;
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsSelectionState::MakeEmpty()
|
|
|
|
{
|
|
|
|
// free any items in the array
|
2001-12-21 01:10:07 +00:00
|
|
|
mArray.Clear();
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool
|
2001-01-28 20:13:07 +00:00
|
|
|
nsSelectionState::IsEmpty()
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
return mArray.IsEmpty();
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* nsRangeUpdater: class for updating nsIDOMRanges in response to editor actions.
|
|
|
|
*/
|
|
|
|
|
2011-10-17 14:59:28 +00:00
|
|
|
nsRangeUpdater::nsRangeUpdater() : mArray(), mLock(false) {}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
nsRangeUpdater::~nsRangeUpdater()
|
|
|
|
{
|
2002-11-10 15:11:08 +00:00
|
|
|
// nothing to do, we don't own the items in our array.
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsRangeUpdater::RegisterRangeItem(nsRangeStore *aRangeItem)
|
|
|
|
{
|
|
|
|
if (!aRangeItem) return;
|
2009-04-22 08:43:15 +00:00
|
|
|
if (mArray.Contains(aRangeItem))
|
2002-11-10 15:11:08 +00:00
|
|
|
{
|
|
|
|
NS_ERROR("tried to register an already registered range");
|
|
|
|
return; // don't register it again. It would get doubly adjusted.
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
mArray.AppendElement(aRangeItem);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsRangeUpdater::DropRangeItem(nsRangeStore *aRangeItem)
|
|
|
|
{
|
|
|
|
if (!aRangeItem) return;
|
|
|
|
mArray.RemoveElement(aRangeItem);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::RegisterSelectionState(nsSelectionState &aSelState)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, theCount = aSelState.mArray.Length();
|
2001-01-28 20:13:07 +00:00
|
|
|
if (theCount < 1) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
for (i=0; i<theCount; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
RegisterRangeItem(&aSelState.mArray[i]);
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
2003-06-30 19:10:53 +00:00
|
|
|
return NS_OK;
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::DropSelectionState(nsSelectionState &aSelState)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, theCount = aSelState.mArray.Length();
|
2001-01-28 20:13:07 +00:00
|
|
|
if (theCount < 1) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
for (i=0; i<theCount; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
DropRangeItem(&aSelState.mArray[i]);
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
2003-06-30 19:10:53 +00:00
|
|
|
return NS_OK;
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// gravity methods:
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::SelAdjCreateNode(nsIDOMNode *aParent, PRInt32 aPosition)
|
|
|
|
{
|
|
|
|
if (mLock) return NS_OK; // lock set by Will/DidReplaceParent, etc...
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aParent, NS_ERROR_NULL_POINTER);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-28 23:15:27 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
nsRangeStore *item;
|
|
|
|
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
if ((item->startNode.get() == aParent) && (item->startOffset > aPosition))
|
|
|
|
item->startOffset++;
|
|
|
|
if ((item->endNode.get() == aParent) && (item->endOffset > aPosition))
|
|
|
|
item->endOffset++;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::SelAdjInsertNode(nsIDOMNode *aParent, PRInt32 aPosition)
|
|
|
|
{
|
|
|
|
return SelAdjCreateNode(aParent, aPosition);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
2002-11-10 15:11:08 +00:00
|
|
|
nsRangeUpdater::SelAdjDeleteNode(nsIDOMNode *aNode)
|
2001-01-28 20:13:07 +00:00
|
|
|
{
|
|
|
|
if (mLock) return NS_OK; // lock set by Will/DidReplaceParent, etc...
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
2002-11-10 15:11:08 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> parent;
|
|
|
|
PRInt32 offset = 0;
|
2001-01-28 20:13:07 +00:00
|
|
|
|
2002-11-10 15:11:08 +00:00
|
|
|
nsresult res = nsEditor::GetNodeLocation(aNode, address_of(parent), &offset);
|
|
|
|
NS_ENSURE_SUCCESS(res, res);
|
|
|
|
|
2002-12-22 01:51:14 +00:00
|
|
|
// check for range endpoints that are after aNode and in the same parent
|
2003-06-30 19:10:53 +00:00
|
|
|
nsRangeStore *item;
|
2001-01-28 20:13:07 +00:00
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
2002-11-10 15:11:08 +00:00
|
|
|
if ((item->startNode.get() == parent) && (item->startOffset > offset))
|
2001-01-28 20:13:07 +00:00
|
|
|
item->startOffset--;
|
2002-11-10 15:11:08 +00:00
|
|
|
if ((item->endNode.get() == parent) && (item->endOffset > offset))
|
2001-01-28 20:13:07 +00:00
|
|
|
item->endOffset--;
|
2002-12-22 07:48:32 +00:00
|
|
|
|
|
|
|
// check for range endpoints that are in aNode
|
|
|
|
if (item->startNode == aNode)
|
|
|
|
{
|
|
|
|
item->startNode = parent;
|
|
|
|
item->startOffset = offset;
|
|
|
|
}
|
|
|
|
if (item->endNode == aNode)
|
|
|
|
{
|
|
|
|
item->endNode = parent;
|
|
|
|
item->endOffset = offset;
|
|
|
|
}
|
2002-12-22 01:51:14 +00:00
|
|
|
|
2002-12-22 07:48:32 +00:00
|
|
|
// check for range endpoints that are in descendants of aNode
|
|
|
|
nsCOMPtr<nsIDOMNode> oldStart;
|
|
|
|
if (nsEditorUtils::IsDescendantOf(item->startNode, aNode))
|
|
|
|
{
|
|
|
|
oldStart = item->startNode; // save for efficiency hack below.
|
|
|
|
item->startNode = parent;
|
|
|
|
item->startOffset = offset;
|
|
|
|
}
|
2002-12-22 01:51:14 +00:00
|
|
|
|
2002-12-22 07:48:32 +00:00
|
|
|
// avoid having to call IsDescendantOf() for common case of range startnode == range endnode.
|
|
|
|
if ((item->endNode == oldStart) || nsEditorUtils::IsDescendantOf(item->endNode, aNode))
|
|
|
|
{
|
|
|
|
item->endNode = parent;
|
|
|
|
item->endOffset = offset;
|
|
|
|
}
|
2002-12-22 01:51:14 +00:00
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::SelAdjSplitNode(nsIDOMNode *aOldRightNode, PRInt32 aOffset, nsIDOMNode *aNewLeftNode)
|
|
|
|
{
|
|
|
|
if (mLock) return NS_OK; // lock set by Will/DidReplaceParent, etc...
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aOldRightNode && aNewLeftNode, NS_ERROR_NULL_POINTER);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNode> parent;
|
|
|
|
PRInt32 offset;
|
|
|
|
nsresult result = nsEditor::GetNodeLocation(aOldRightNode, address_of(parent), &offset);
|
2010-06-17 19:27:24 +00:00
|
|
|
NS_ENSURE_SUCCESS(result, result);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
// first part is same as inserting aNewLeftnode
|
|
|
|
result = SelAdjInsertNode(parent,offset-1);
|
2010-06-17 19:27:24 +00:00
|
|
|
NS_ENSURE_SUCCESS(result, result);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
// next step is to check for range enpoints inside aOldRightNode
|
|
|
|
nsRangeStore *item;
|
|
|
|
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
if (item->startNode.get() == aOldRightNode)
|
|
|
|
{
|
|
|
|
if (item->startOffset > aOffset)
|
|
|
|
{
|
|
|
|
item->startOffset -= aOffset;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
item->startNode = aNewLeftNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (item->endNode.get() == aOldRightNode)
|
|
|
|
{
|
|
|
|
if (item->endOffset > aOffset)
|
|
|
|
{
|
|
|
|
item->endOffset -= aOffset;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
item->endNode = aNewLeftNode;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::SelAdjJoinNodes(nsIDOMNode *aLeftNode,
|
|
|
|
nsIDOMNode *aRightNode,
|
|
|
|
nsIDOMNode *aParent,
|
|
|
|
PRInt32 aOffset,
|
|
|
|
PRInt32 aOldLeftNodeLength)
|
|
|
|
{
|
|
|
|
if (mLock) return NS_OK; // lock set by Will/DidReplaceParent, etc...
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aLeftNode && aRightNode && aParent, NS_ERROR_NULL_POINTER);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
nsRangeStore *item;
|
|
|
|
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
if (item->startNode.get() == aParent)
|
|
|
|
{
|
2003-02-27 14:53:03 +00:00
|
|
|
// adjust start point in aParent
|
2001-01-28 20:13:07 +00:00
|
|
|
if (item->startOffset > aOffset)
|
|
|
|
{
|
|
|
|
item->startOffset--;
|
|
|
|
}
|
|
|
|
else if (item->startOffset == aOffset)
|
|
|
|
{
|
|
|
|
// join keeps right hand node
|
|
|
|
item->startNode = aRightNode;
|
|
|
|
item->startOffset = aOldLeftNodeLength;
|
|
|
|
}
|
|
|
|
}
|
2003-02-27 14:53:03 +00:00
|
|
|
else if (item->startNode.get() == aRightNode)
|
|
|
|
{
|
|
|
|
// adjust start point in aRightNode
|
|
|
|
item->startOffset += aOldLeftNodeLength;
|
|
|
|
}
|
|
|
|
else if (item->startNode.get() == aLeftNode)
|
|
|
|
{
|
|
|
|
// adjust start point in aLeftNode
|
|
|
|
item->startNode = aRightNode;
|
|
|
|
}
|
|
|
|
|
2001-01-28 20:13:07 +00:00
|
|
|
if (item->endNode.get() == aParent)
|
|
|
|
{
|
2003-02-27 14:53:03 +00:00
|
|
|
// adjust end point in aParent
|
2001-01-28 20:13:07 +00:00
|
|
|
if (item->endOffset > aOffset)
|
|
|
|
{
|
|
|
|
item->endOffset--;
|
|
|
|
}
|
|
|
|
else if (item->endOffset == aOffset)
|
|
|
|
{
|
|
|
|
// join keeps right hand node
|
|
|
|
item->endNode = aRightNode;
|
|
|
|
item->endOffset = aOldLeftNodeLength;
|
|
|
|
}
|
|
|
|
}
|
2003-02-27 14:53:03 +00:00
|
|
|
else if (item->endNode.get() == aRightNode)
|
|
|
|
{
|
|
|
|
// adjust end point in aRightNode
|
|
|
|
item->endOffset += aOldLeftNodeLength;
|
|
|
|
}
|
|
|
|
else if (item->endNode.get() == aLeftNode)
|
|
|
|
{
|
|
|
|
// adjust end point in aLeftNode
|
2002-12-22 01:51:14 +00:00
|
|
|
item->endNode = aRightNode;
|
2003-02-27 14:53:03 +00:00
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
2002-04-13 23:54:59 +00:00
|
|
|
nsRangeUpdater::SelAdjInsertText(nsIDOMCharacterData *aTextNode, PRInt32 aOffset, const nsAString &aString)
|
2001-01-28 20:13:07 +00:00
|
|
|
{
|
|
|
|
if (mLock) return NS_OK; // lock set by Will/DidReplaceParent, etc...
|
2002-04-13 23:54:59 +00:00
|
|
|
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2002-04-13 23:54:59 +00:00
|
|
|
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(aTextNode));
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
|
2002-04-13 23:54:59 +00:00
|
|
|
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 len=aString.Length(), i;
|
2003-06-30 19:10:53 +00:00
|
|
|
nsRangeStore *item;
|
2002-04-13 23:54:59 +00:00
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2002-04-13 23:54:59 +00:00
|
|
|
|
|
|
|
if ((item->startNode.get() == node) && (item->startOffset > aOffset))
|
|
|
|
item->startOffset += len;
|
|
|
|
if ((item->endNode.get() == node) && (item->endOffset > aOffset))
|
|
|
|
item->endOffset += len;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::SelAdjDeleteText(nsIDOMCharacterData *aTextNode, PRInt32 aOffset, PRInt32 aLength)
|
|
|
|
{
|
|
|
|
if (mLock) return NS_OK; // lock set by Will/DidReplaceParent, etc...
|
2002-04-13 23:54:59 +00:00
|
|
|
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2002-04-13 23:54:59 +00:00
|
|
|
nsRangeStore *item;
|
|
|
|
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(aTextNode));
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
|
2002-04-13 23:54:59 +00:00
|
|
|
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2002-04-13 23:54:59 +00:00
|
|
|
|
|
|
|
if ((item->startNode.get() == node) && (item->startOffset > aOffset))
|
|
|
|
{
|
|
|
|
item->startOffset -= aLength;
|
|
|
|
if (item->startOffset < 0) item->startOffset = 0;
|
|
|
|
}
|
|
|
|
if ((item->endNode.get() == node) && (item->endOffset > aOffset))
|
|
|
|
{
|
|
|
|
item->endOffset -= aLength;
|
|
|
|
if (item->endOffset < 0) item->endOffset = 0;
|
|
|
|
}
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::WillReplaceContainer()
|
|
|
|
{
|
|
|
|
if (mLock) return NS_ERROR_UNEXPECTED;
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = true;
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::DidReplaceContainer(nsIDOMNode *aOriginalNode, nsIDOMNode *aNewNode)
|
|
|
|
{
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = false;
|
2001-01-28 20:13:07 +00:00
|
|
|
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aOriginalNode && aNewNode, NS_ERROR_NULL_POINTER);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
nsRangeStore *item;
|
|
|
|
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
if (item->startNode.get() == aOriginalNode)
|
|
|
|
item->startNode = aNewNode;
|
|
|
|
if (item->endNode.get() == aOriginalNode)
|
|
|
|
item->endNode = aNewNode;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::WillRemoveContainer()
|
|
|
|
{
|
|
|
|
if (mLock) return NS_ERROR_UNEXPECTED;
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = true;
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::DidRemoveContainer(nsIDOMNode *aNode, nsIDOMNode *aParent, PRInt32 aOffset, PRUint32 aNodeOrigLen)
|
|
|
|
{
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = false;
|
2001-01-28 20:13:07 +00:00
|
|
|
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aNode && aParent, NS_ERROR_NULL_POINTER);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
nsRangeStore *item;
|
|
|
|
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
if (item->startNode.get() == aNode)
|
|
|
|
{
|
|
|
|
item->startNode = aParent;
|
|
|
|
item->startOffset += aOffset;
|
|
|
|
}
|
2002-04-06 19:07:47 +00:00
|
|
|
else if ((item->startNode.get() == aParent) && (item->startOffset > aOffset))
|
|
|
|
item->startOffset += (PRInt32)aNodeOrigLen-1;
|
|
|
|
|
2001-01-28 20:13:07 +00:00
|
|
|
if (item->endNode.get() == aNode)
|
|
|
|
{
|
|
|
|
item->endNode = aParent;
|
|
|
|
item->endOffset += aOffset;
|
|
|
|
}
|
2002-04-06 19:07:47 +00:00
|
|
|
else if ((item->endNode.get() == aParent) && (item->endOffset > aOffset))
|
2001-01-28 20:13:07 +00:00
|
|
|
item->endOffset += (PRInt32)aNodeOrigLen-1;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::WillInsertContainer()
|
|
|
|
{
|
|
|
|
if (mLock) return NS_ERROR_UNEXPECTED;
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = true;
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::DidInsertContainer()
|
|
|
|
{
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = false;
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::WillMoveNode()
|
|
|
|
{
|
|
|
|
if (mLock) return NS_ERROR_UNEXPECTED;
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = true;
|
2001-01-28 20:13:07 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsRangeUpdater::DidMoveNode(nsIDOMNode *aOldParent, PRInt32 aOldOffset, nsIDOMNode *aNewParent, PRInt32 aNewOffset)
|
|
|
|
{
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
|
2011-10-17 14:59:28 +00:00
|
|
|
mLock = false;
|
2001-01-28 20:13:07 +00:00
|
|
|
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aOldParent && aNewParent, NS_ERROR_NULL_POINTER);
|
2009-04-22 08:43:15 +00:00
|
|
|
PRUint32 i, count = mArray.Length();
|
2010-06-29 18:14:54 +00:00
|
|
|
if (!count) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
nsRangeStore *item;
|
|
|
|
|
|
|
|
for (i=0; i<count; i++)
|
|
|
|
{
|
2009-04-22 08:43:15 +00:00
|
|
|
item = mArray[i];
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
|
|
|
|
// like a delete in aOldParent
|
|
|
|
if ((item->startNode.get() == aOldParent) && (item->startOffset > aOldOffset))
|
|
|
|
item->startOffset--;
|
|
|
|
if ((item->endNode.get() == aOldParent) && (item->endOffset > aOldOffset))
|
|
|
|
item->endOffset--;
|
|
|
|
|
|
|
|
// and like an insert in aNewParent
|
|
|
|
if ((item->startNode.get() == aNewParent) && (item->startOffset > aNewOffset))
|
|
|
|
item->startOffset++;
|
|
|
|
if ((item->endNode.get() == aNewParent) && (item->endOffset > aNewOffset))
|
|
|
|
item->endOffset++;
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* helper class for nsSelectionState. nsRangeStore stores range endpoints.
|
|
|
|
*/
|
|
|
|
|
|
|
|
// DEBUG: PRInt32 nsRangeStore::n = 0;
|
|
|
|
|
|
|
|
nsRangeStore::nsRangeStore()
|
|
|
|
{
|
|
|
|
// DEBUG: n++; printf("range store alloc count=%d\n", n);
|
|
|
|
}
|
|
|
|
nsRangeStore::~nsRangeStore()
|
|
|
|
{
|
|
|
|
// DEBUG: n--; printf("range store alloc count=%d\n", n);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult nsRangeStore::StoreRange(nsIDOMRange *aRange)
|
|
|
|
{
|
2010-06-17 19:41:16 +00:00
|
|
|
NS_ENSURE_TRUE(aRange, NS_ERROR_NULL_POINTER);
|
2001-01-28 20:13:07 +00:00
|
|
|
aRange->GetStartContainer(getter_AddRefs(startNode));
|
|
|
|
aRange->GetEndContainer(getter_AddRefs(endNode));
|
|
|
|
aRange->GetStartOffset(&startOffset);
|
|
|
|
aRange->GetEndOffset(&endOffset);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-01-10 14:19:54 +00:00
|
|
|
nsresult nsRangeStore::GetRange(nsRange** outRange)
|
2001-01-28 20:13:07 +00:00
|
|
|
{
|
2012-01-15 08:13:12 +00:00
|
|
|
return nsRange::CreateRange(startNode, startOffset, endNode, endOffset,
|
|
|
|
outRange);
|
2001-01-28 20:13:07 +00:00
|
|
|
}
|