--- a/editor/libeditor/DeleteNodeTransaction.cpp
+++ b/editor/libeditor/DeleteNodeTransaction.cpp
@@ -1,15 +1,15 @@
/* -*- 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 "DeleteNodeTransaction.h"
-#include "SelectionState.h" // nsRangeUpdater
+#include "SelectionState.h" // RangeUpdater
#include "nsDebug.h"
#include "nsEditor.h"
#include "nsError.h"
#include "nsAString.h"
namespace mozilla {
DeleteNodeTransaction::DeleteNodeTransaction()
@@ -30,17 +30,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Delet
NS_IMPL_ADDREF_INHERITED(DeleteNodeTransaction, EditTransactionBase)
NS_IMPL_RELEASE_INHERITED(DeleteNodeTransaction, EditTransactionBase)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteNodeTransaction)
NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
nsresult
DeleteNodeTransaction::Init(nsEditor* aEditor,
nsINode* aNode,
- nsRangeUpdater* aRangeUpdater)
+ RangeUpdater* aRangeUpdater)
{
NS_ENSURE_TRUE(aEditor && aNode, NS_ERROR_NULL_POINTER);
mEditor = aEditor;
mNode = aNode;
mParent = aNode->GetParentNode();
// do nothing if the node has a parent and it's read-only
NS_ENSURE_TRUE(!mParent || mEditor->IsModifiableNode(mParent),
--- a/editor/libeditor/DeleteNodeTransaction.h
+++ b/editor/libeditor/DeleteNodeTransaction.h
@@ -10,32 +10,33 @@
#include "nsCOMPtr.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIContent.h"
#include "nsINode.h"
#include "nsISupportsImpl.h"
#include "nscore.h"
class nsEditor;
-class nsRangeUpdater;
namespace mozilla {
+class RangeUpdater;
+
/**
* A transaction that deletes a single element
*/
class DeleteNodeTransaction final : public EditTransactionBase
{
public:
/**
* Initialize the transaction.
* @param aElement The node to delete.
*/
nsresult Init(nsEditor* aEditor, nsINode* aNode,
- nsRangeUpdater* aRangeUpdater);
+ RangeUpdater* aRangeUpdater);
DeleteNodeTransaction();
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteNodeTransaction,
EditTransactionBase)
NS_DECL_EDITTRANSACTIONBASE
@@ -53,14 +54,14 @@ protected:
// Next sibling to remember for undo/redo purposes.
nsCOMPtr<nsIContent> mRefNode;
// The editor for this transaction.
nsEditor* mEditor;
// Range updater object.
- nsRangeUpdater* mRangeUpdater;
+ RangeUpdater* mRangeUpdater;
};
} // namespace mozilla
#endif // #ifndef DeleteNodeTransaction_h
--- a/editor/libeditor/DeleteRangeTransaction.cpp
+++ b/editor/libeditor/DeleteRangeTransaction.cpp
@@ -36,17 +36,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Delet
mRange)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteRangeTransaction)
NS_INTERFACE_MAP_END_INHERITING(EditAggregateTransaction)
nsresult
DeleteRangeTransaction::Init(nsEditor* aEditor,
nsRange* aRange,
- nsRangeUpdater* aRangeUpdater)
+ RangeUpdater* aRangeUpdater)
{
MOZ_ASSERT(aEditor && aRange);
mEditor = aEditor;
mRange = aRange->CloneRange();
mRangeUpdater = aRangeUpdater;
NS_ENSURE_TRUE(mEditor->IsModifiableNode(mRange->GetStartParent()),
--- a/editor/libeditor/DeleteRangeTransaction.h
+++ b/editor/libeditor/DeleteRangeTransaction.h
@@ -11,34 +11,35 @@
#include "nsID.h"
#include "nsIEditor.h"
#include "nsISupportsImpl.h"
#include "nsRange.h"
#include "nscore.h"
class nsEditor;
class nsINode;
-class nsRangeUpdater;
namespace mozilla {
+class RangeUpdater;
+
/**
* A transaction that deletes an entire range in the content tree
*/
class DeleteRangeTransaction final : public EditAggregateTransaction
{
public:
/**
* Initialize the transaction.
* @param aEditor The object providing basic editing operations.
* @param aRange The range to delete.
*/
nsresult Init(nsEditor* aEditor,
nsRange* aRange,
- nsRangeUpdater* aRangeUpdater);
+ RangeUpdater* aRangeUpdater);
DeleteRangeTransaction();
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteRangeTransaction,
EditAggregateTransaction)
NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
NS_DECL_EDITTRANSACTIONBASE
@@ -64,14 +65,14 @@ protected:
// P1 in the range.
RefPtr<nsRange> mRange;
// The editor for this transaction.
nsEditor* mEditor;
// Range updater object.
- nsRangeUpdater* mRangeUpdater;
+ RangeUpdater* mRangeUpdater;
};
} // namespace mozilla
#endif // #ifndef DeleteRangeTransaction_h
--- a/editor/libeditor/DeleteTextTransaction.cpp
+++ b/editor/libeditor/DeleteTextTransaction.cpp
@@ -18,17 +18,17 @@ namespace mozilla {
using namespace dom;
DeleteTextTransaction::DeleteTextTransaction(
nsEditor& aEditor,
nsGenericDOMDataNode& aCharData,
uint32_t aOffset,
uint32_t aNumCharsToDelete,
- nsRangeUpdater* aRangeUpdater)
+ RangeUpdater* aRangeUpdater)
: mEditor(aEditor)
, mCharData(&aCharData)
, mOffset(aOffset)
, mNumCharsToDelete(aNumCharsToDelete)
, mRangeUpdater(aRangeUpdater)
{
NS_ASSERTION(mCharData->Length() >= aOffset + aNumCharsToDelete,
"Trying to delete more characters than in node");
--- a/editor/libeditor/DeleteTextTransaction.h
+++ b/editor/libeditor/DeleteTextTransaction.h
@@ -10,20 +10,21 @@
#include "nsCOMPtr.h"
#include "nsCycleCollectionParticipant.h"
#include "nsGenericDOMDataNode.h"
#include "nsID.h"
#include "nsString.h"
#include "nscore.h"
class nsEditor;
-class nsRangeUpdater;
namespace mozilla {
+class RangeUpdater;
+
/**
* A transaction that removes text from a content node.
*/
class DeleteTextTransaction final : public EditTransactionBase
{
public:
/**
* Initialize the transaction.
@@ -32,17 +33,17 @@ public:
* @param aOffset The location in aElement to begin the deletion.
* @param aNumCharsToDelete The number of characters to delete. Not the
* number of bytes!
*/
DeleteTextTransaction(nsEditor& aEditor,
nsGenericDOMDataNode& aCharData,
uint32_t aOffset,
uint32_t aNumCharsToDelete,
- nsRangeUpdater* aRangeUpdater);
+ RangeUpdater* aRangeUpdater);
nsresult Init();
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteTextTransaction,
EditTransactionBase)
NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
NS_DECL_EDITTRANSACTIONBASE
@@ -63,14 +64,14 @@ protected:
// The number of characters to delete.
uint32_t mNumCharsToDelete;
// The text that was deleted.
nsString mDeletedText;
// Range updater object.
- nsRangeUpdater* mRangeUpdater;
+ RangeUpdater* mRangeUpdater;
};
} // namespace mozilla
#endif // #ifndef DeleteTextTransaction_h
--- a/editor/libeditor/SelectionState.cpp
+++ b/editor/libeditor/SelectionState.cpp
@@ -132,83 +132,84 @@ SelectionState::MakeEmpty()
}
bool
SelectionState::IsEmpty()
{
return mArray.IsEmpty();
}
-} // namespace mozilla
-
-using namespace mozilla;
-using namespace mozilla::dom;
+/******************************************************************************
+ * mozilla::RangeUpdater
+ *
+ * Class for updating nsRanges in response to editor actions.
+ ******************************************************************************/
-/***************************************************************************
- * nsRangeUpdater: class for updating nsRanges in response to editor actions.
- */
+RangeUpdater::RangeUpdater()
+ : mLock(false)
+{
+}
-nsRangeUpdater::nsRangeUpdater() : mArray(), mLock(false) {}
-
-nsRangeUpdater::~nsRangeUpdater()
+RangeUpdater::~RangeUpdater()
{
// nothing to do, we don't own the items in our array.
}
void
-nsRangeUpdater::RegisterRangeItem(RangeItem* aRangeItem)
+RangeUpdater::RegisterRangeItem(RangeItem* aRangeItem)
{
if (!aRangeItem) return;
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
-nsRangeUpdater::DropRangeItem(RangeItem* aRangeItem)
+RangeUpdater::DropRangeItem(RangeItem* aRangeItem)
{
if (!aRangeItem) return;
mArray.RemoveElement(aRangeItem);
}
nsresult
-nsRangeUpdater::RegisterSelectionState(SelectionState& aSelState)
+RangeUpdater::RegisterSelectionState(SelectionState& aSelState)
{
uint32_t i, theCount = aSelState.mArray.Length();
if (theCount < 1) return NS_ERROR_FAILURE;
for (i=0; i<theCount; i++)
{
RegisterRangeItem(aSelState.mArray[i]);
}
return NS_OK;
}
nsresult
-nsRangeUpdater::DropSelectionState(SelectionState& aSelState)
+RangeUpdater::DropSelectionState(SelectionState& aSelState)
{
uint32_t i, theCount = aSelState.mArray.Length();
if (theCount < 1) return NS_ERROR_FAILURE;
for (i=0; i<theCount; i++)
{
DropRangeItem(aSelState.mArray[i]);
}
return NS_OK;
}
// gravity methods:
nsresult
-nsRangeUpdater::SelAdjCreateNode(nsINode* aParent, int32_t aPosition)
+RangeUpdater::SelAdjCreateNode(nsINode* aParent,
+ int32_t aPosition)
{
if (mLock) {
// lock set by Will/DidReplaceParent, etc...
return NS_OK;
}
NS_ENSURE_TRUE(aParent, NS_ERROR_NULL_POINTER);
uint32_t count = mArray.Length();
if (!count) {
@@ -225,36 +226,39 @@ nsRangeUpdater::SelAdjCreateNode(nsINode
if (item->endNode == aParent && item->endOffset > aPosition) {
item->endOffset++;
}
}
return NS_OK;
}
nsresult
-nsRangeUpdater::SelAdjCreateNode(nsIDOMNode* aParent, int32_t aPosition)
+RangeUpdater::SelAdjCreateNode(nsIDOMNode* aParent,
+ int32_t aPosition)
{
nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
return SelAdjCreateNode(parent, aPosition);
}
nsresult
-nsRangeUpdater::SelAdjInsertNode(nsINode* aParent, int32_t aPosition)
+RangeUpdater::SelAdjInsertNode(nsINode* aParent,
+ int32_t aPosition)
{
return SelAdjCreateNode(aParent, aPosition);
}
nsresult
-nsRangeUpdater::SelAdjInsertNode(nsIDOMNode *aParent, int32_t aPosition)
+RangeUpdater::SelAdjInsertNode(nsIDOMNode* aParent,
+ int32_t aPosition)
{
return SelAdjCreateNode(aParent, aPosition);
}
void
-nsRangeUpdater::SelAdjDeleteNode(nsINode* aNode)
+RangeUpdater::SelAdjDeleteNode(nsINode* aNode)
{
if (mLock) {
// lock set by Will/DidReplaceParent, etc...
return;
}
MOZ_ASSERT(aNode);
uint32_t count = mArray.Length();
if (!count) {
@@ -300,27 +304,27 @@ nsRangeUpdater::SelAdjDeleteNode(nsINode
{
item->endNode = parent;
item->endOffset = offset;
}
}
}
void
-nsRangeUpdater::SelAdjDeleteNode(nsIDOMNode *aNode)
+RangeUpdater::SelAdjDeleteNode(nsIDOMNode* aNode)
{
nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
NS_ENSURE_TRUE(node, );
return SelAdjDeleteNode(node);
}
-
nsresult
-nsRangeUpdater::SelAdjSplitNode(nsIContent& aOldRightNode, int32_t aOffset,
- nsIContent* aNewLeftNode)
+RangeUpdater::SelAdjSplitNode(nsIContent& aOldRightNode,
+ int32_t aOffset,
+ nsIContent* aNewLeftNode)
{
if (mLock) {
// lock set by Will/DidReplaceParent, etc...
return NS_OK;
}
NS_ENSURE_TRUE(aNewLeftNode, NS_ERROR_NULL_POINTER);
uint32_t count = mArray.Length();
if (!count) {
@@ -353,21 +357,21 @@ nsRangeUpdater::SelAdjSplitNode(nsIConte
item->endNode = aNewLeftNode;
}
}
}
return NS_OK;
}
nsresult
-nsRangeUpdater::SelAdjJoinNodes(nsINode& aLeftNode,
- nsINode& aRightNode,
- nsINode& aParent,
- int32_t aOffset,
- int32_t aOldLeftNodeLength)
+RangeUpdater::SelAdjJoinNodes(nsINode& aLeftNode,
+ nsINode& aRightNode,
+ nsINode& aParent,
+ int32_t aOffset,
+ int32_t aOldLeftNodeLength)
{
if (mLock) {
// lock set by Will/DidReplaceParent, etc...
return NS_OK;
}
uint32_t count = mArray.Length();
if (!count) {
return NS_OK;
@@ -410,20 +414,20 @@ nsRangeUpdater::SelAdjJoinNodes(nsINode&
// adjust end point in aLeftNode
item->endNode = &aRightNode;
}
}
return NS_OK;
}
-
void
-nsRangeUpdater::SelAdjInsertText(Text& aTextNode, int32_t aOffset,
- const nsAString& aString)
+RangeUpdater::SelAdjInsertText(Text& aTextNode,
+ int32_t aOffset,
+ const nsAString& aString)
{
if (mLock) {
// lock set by Will/DidReplaceParent, etc...
return;
}
uint32_t count = mArray.Length();
if (!count) {
@@ -441,18 +445,19 @@ nsRangeUpdater::SelAdjInsertText(Text& a
if (item->endNode == &aTextNode && item->endOffset > aOffset) {
item->endOffset += len;
}
}
return;
}
nsresult
-nsRangeUpdater::SelAdjDeleteText(nsIContent* aTextNode, int32_t aOffset,
- int32_t aLength)
+RangeUpdater::SelAdjDeleteText(nsIContent* aTextNode,
+ int32_t aOffset,
+ int32_t aLength)
{
if (mLock) {
// lock set by Will/DidReplaceParent, etc...
return NS_OK;
}
uint32_t count = mArray.Length();
if (!count) {
@@ -476,35 +481,35 @@ nsRangeUpdater::SelAdjDeleteText(nsICont
item->endOffset = 0;
}
}
}
return NS_OK;
}
nsresult
-nsRangeUpdater::SelAdjDeleteText(nsIDOMCharacterData* aTextNode,
- int32_t aOffset, int32_t aLength)
+RangeUpdater::SelAdjDeleteText(nsIDOMCharacterData* aTextNode,
+ int32_t aOffset,
+ int32_t aLength)
{
nsCOMPtr<nsIContent> textNode = do_QueryInterface(aTextNode);
return SelAdjDeleteText(textNode, aOffset, aLength);
}
-
nsresult
-nsRangeUpdater::WillReplaceContainer()
+RangeUpdater::WillReplaceContainer()
{
if (mLock) return NS_ERROR_UNEXPECTED;
mLock = true;
return NS_OK;
}
-
nsresult
-nsRangeUpdater::DidReplaceContainer(Element* aOriginalNode, Element* aNewNode)
+RangeUpdater::DidReplaceContainer(Element* aOriginalNode,
+ Element* aNewNode)
{
NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
mLock = false;
NS_ENSURE_TRUE(aOriginalNode && aNewNode, NS_ERROR_NULL_POINTER);
uint32_t count = mArray.Length();
if (!count) {
return NS_OK;
@@ -519,29 +524,29 @@ nsRangeUpdater::DidReplaceContainer(Elem
}
if (item->endNode == aOriginalNode) {
item->endNode = aNewNode;
}
}
return NS_OK;
}
-
nsresult
-nsRangeUpdater::WillRemoveContainer()
+RangeUpdater::WillRemoveContainer()
{
if (mLock) return NS_ERROR_UNEXPECTED;
mLock = true;
return NS_OK;
}
-
nsresult
-nsRangeUpdater::DidRemoveContainer(nsINode* aNode, nsINode* aParent,
- int32_t aOffset, uint32_t aNodeOrigLen)
+RangeUpdater::DidRemoveContainer(nsINode* aNode,
+ nsINode* aParent,
+ int32_t aOffset,
+ uint32_t aNodeOrigLen)
{
NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
mLock = false;
NS_ENSURE_TRUE(aNode && aParent, NS_ERROR_NULL_POINTER);
uint32_t count = mArray.Length();
if (!count) {
return NS_OK;
@@ -564,52 +569,50 @@ nsRangeUpdater::DidRemoveContainer(nsINo
} else if (item->endNode == aParent && item->endOffset > aOffset) {
item->endOffset += (int32_t)aNodeOrigLen - 1;
}
}
return NS_OK;
}
nsresult
-nsRangeUpdater::DidRemoveContainer(nsIDOMNode* aNode, nsIDOMNode* aParent,
- int32_t aOffset, uint32_t aNodeOrigLen)
+RangeUpdater::DidRemoveContainer(nsIDOMNode* aNode,
+ nsIDOMNode* aParent,
+ int32_t aOffset,
+ uint32_t aNodeOrigLen)
{
nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
return DidRemoveContainer(node, parent, aOffset, aNodeOrigLen);
}
-
nsresult
-nsRangeUpdater::WillInsertContainer()
+RangeUpdater::WillInsertContainer()
{
if (mLock) return NS_ERROR_UNEXPECTED;
mLock = true;
return NS_OK;
}
-
nsresult
-nsRangeUpdater::DidInsertContainer()
+RangeUpdater::DidInsertContainer()
{
NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
mLock = false;
return NS_OK;
}
-
void
-nsRangeUpdater::WillMoveNode()
+RangeUpdater::WillMoveNode()
{
mLock = true;
}
-
void
-nsRangeUpdater::DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
+RangeUpdater::DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
nsINode* aNewParent, int32_t aNewOffset)
{
MOZ_ASSERT(aOldParent);
MOZ_ASSERT(aNewParent);
NS_ENSURE_TRUE_VOID(mLock);
mLock = false;
for (uint32_t i = 0, count = mArray.Length(); i < count; ++i) {
@@ -629,18 +632,16 @@ nsRangeUpdater::DidMoveNode(nsINode* aOl
item->startOffset++;
}
if (item->endNode == aNewParent && item->endOffset > aNewOffset) {
item->endOffset++;
}
}
}
-namespace mozilla {
-
/******************************************************************************
* mozilla::RangeItem
*
* Helper struct for SelectionState. This stores range endpoints.
******************************************************************************/
RangeItem::RangeItem()
{
--- a/editor/libeditor/SelectionState.h
+++ b/editor/libeditor/SelectionState.h
@@ -10,18 +10,18 @@
#include "nsIDOMNode.h"
#include "nsINode.h"
#include "nsTArray.h"
#include "nscore.h"
class nsCycleCollectionTraversalCallback;
class nsIDOMCharacterData;
class nsRange;
-class nsRangeUpdater;
namespace mozilla {
+class RangeUpdater;
namespace dom {
class Selection;
class Text;
} // namespace dom
/**
* A helper struct for saving/setting ranges.
*/
@@ -64,17 +64,17 @@ public:
nsresult RestoreSelection(dom::Selection* aSel);
bool IsCollapsed();
bool IsEqual(SelectionState *aSelState);
void MakeEmpty();
bool IsEmpty();
private:
nsTArray<RefPtr<RangeItem>> mArray;
- friend class nsRangeUpdater;
+ friend class RangeUpdater;
friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
SelectionState&,
const char*,
uint32_t);
friend void ImplCycleCollectionUnlink(SelectionState&);
};
inline void
@@ -87,124 +87,127 @@ ImplCycleCollectionTraverse(nsCycleColle
}
inline void
ImplCycleCollectionUnlink(SelectionState& aField)
{
ImplCycleCollectionUnlink(aField.mArray);
}
-} // namespace mozilla
-
-class nsRangeUpdater
+class RangeUpdater final
{
- public:
+public:
+ RangeUpdater();
+ ~RangeUpdater();
- nsRangeUpdater();
- ~nsRangeUpdater();
-
- void RegisterRangeItem(mozilla::RangeItem* aRangeItem);
- void DropRangeItem(mozilla::RangeItem* aRangeItem);
- nsresult RegisterSelectionState(mozilla::SelectionState& aSelState);
- nsresult DropSelectionState(mozilla::SelectionState& aSelState);
+ void RegisterRangeItem(RangeItem* aRangeItem);
+ void DropRangeItem(RangeItem* aRangeItem);
+ nsresult RegisterSelectionState(SelectionState& aSelState);
+ nsresult DropSelectionState(SelectionState& aSelState);
- // editor selection gravity routines. Note that we can't always depend on
- // DOM Range gravity to do what we want to the "real" selection. For instance,
- // if you move a node, that corresponds to deleting it and reinserting it.
- // DOM Range gravity will promote the selection out of the node on deletion,
- // which is not what you want if you know you are reinserting it.
- nsresult SelAdjCreateNode(nsINode* aParent, int32_t aPosition);
- nsresult SelAdjCreateNode(nsIDOMNode *aParent, int32_t aPosition);
- nsresult SelAdjInsertNode(nsINode* aParent, int32_t aPosition);
- nsresult SelAdjInsertNode(nsIDOMNode *aParent, int32_t aPosition);
- void SelAdjDeleteNode(nsINode* aNode);
- void SelAdjDeleteNode(nsIDOMNode *aNode);
- nsresult SelAdjSplitNode(nsIContent& aOldRightNode, int32_t aOffset,
- nsIContent* aNewLeftNode);
- nsresult SelAdjJoinNodes(nsINode& aLeftNode,
- nsINode& aRightNode,
- nsINode& aParent,
- int32_t aOffset,
- int32_t aOldLeftNodeLength);
- void SelAdjInsertText(mozilla::dom::Text& aTextNode, int32_t aOffset,
- const nsAString &aString);
- nsresult SelAdjDeleteText(nsIContent* aTextNode, int32_t aOffset,
- int32_t aLength);
- nsresult SelAdjDeleteText(nsIDOMCharacterData *aTextNode, int32_t aOffset, int32_t aLength);
- // the following gravity routines need will/did sandwiches, because the other gravity
- // routines will be called inside of these sandwiches, but should be ignored.
- nsresult WillReplaceContainer();
- nsresult DidReplaceContainer(mozilla::dom::Element* aOriginalNode,
- mozilla::dom::Element* aNewNode);
- nsresult WillRemoveContainer();
- nsresult DidRemoveContainer(nsINode* aNode, nsINode* aParent,
- int32_t aOffset, uint32_t aNodeOrigLen);
- nsresult DidRemoveContainer(nsIDOMNode *aNode, nsIDOMNode *aParent, int32_t aOffset, uint32_t aNodeOrigLen);
- nsresult WillInsertContainer();
- nsresult DidInsertContainer();
- void WillMoveNode();
- void DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
- nsINode* aNewParent, int32_t aNewOffset);
- private:
- friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
- nsRangeUpdater&,
- const char*,
- uint32_t);
- friend void ImplCycleCollectionUnlink(nsRangeUpdater& aField);
+ // editor selection gravity routines. Note that we can't always depend on
+ // DOM Range gravity to do what we want to the "real" selection. For instance,
+ // if you move a node, that corresponds to deleting it and reinserting it.
+ // DOM Range gravity will promote the selection out of the node on deletion,
+ // which is not what you want if you know you are reinserting it.
+ nsresult SelAdjCreateNode(nsINode* aParent, int32_t aPosition);
+ nsresult SelAdjCreateNode(nsIDOMNode* aParent, int32_t aPosition);
+ nsresult SelAdjInsertNode(nsINode* aParent, int32_t aPosition);
+ nsresult SelAdjInsertNode(nsIDOMNode* aParent, int32_t aPosition);
+ void SelAdjDeleteNode(nsINode* aNode);
+ void SelAdjDeleteNode(nsIDOMNode* aNode);
+ nsresult SelAdjSplitNode(nsIContent& aOldRightNode, int32_t aOffset,
+ nsIContent* aNewLeftNode);
+ nsresult SelAdjJoinNodes(nsINode& aLeftNode,
+ nsINode& aRightNode,
+ nsINode& aParent,
+ int32_t aOffset,
+ int32_t aOldLeftNodeLength);
+ void SelAdjInsertText(dom::Text& aTextNode, int32_t aOffset,
+ const nsAString &aString);
+ nsresult SelAdjDeleteText(nsIContent* aTextNode, int32_t aOffset,
+ int32_t aLength);
+ nsresult SelAdjDeleteText(nsIDOMCharacterData* aTextNode,
+ int32_t aOffset, int32_t aLength);
+ // the following gravity routines need will/did sandwiches, because the other
+ // gravity routines will be called inside of these sandwiches, but should be
+ // ignored.
+ nsresult WillReplaceContainer();
+ nsresult DidReplaceContainer(dom::Element* aOriginalNode,
+ dom::Element* aNewNode);
+ nsresult WillRemoveContainer();
+ nsresult DidRemoveContainer(nsINode* aNode, nsINode* aParent,
+ int32_t aOffset, uint32_t aNodeOrigLen);
+ nsresult DidRemoveContainer(nsIDOMNode* aNode, nsIDOMNode* aParent,
+ int32_t aOffset, uint32_t aNodeOrigLen);
+ nsresult WillInsertContainer();
+ nsresult DidInsertContainer();
+ void WillMoveNode();
+ void DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
+ nsINode* aNewParent, int32_t aNewOffset);
- nsTArray<RefPtr<mozilla::RangeItem>> mArray;
- bool mLock;
+private:
+ friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
+ RangeUpdater&,
+ const char*,
+ uint32_t);
+ friend void ImplCycleCollectionUnlink(RangeUpdater& aField);
+
+ nsTArray<RefPtr<RangeItem>> mArray;
+ bool mLock;
};
inline void
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
- nsRangeUpdater& aField,
+ RangeUpdater& aField,
const char* aName,
uint32_t aFlags = 0)
{
ImplCycleCollectionTraverse(aCallback, aField.mArray, aName, aFlags);
}
inline void
-ImplCycleCollectionUnlink(nsRangeUpdater& aField)
+ImplCycleCollectionUnlink(RangeUpdater& aField)
{
ImplCycleCollectionUnlink(aField.mArray);
}
+} // namespace mozilla
+
/***************************************************************************
* helper class for using SelectionState. stack based class for doing
* preservation of dom points across editor actions
*/
class MOZ_STACK_CLASS nsAutoTrackDOMPoint
{
private:
- nsRangeUpdater &mRU;
+ mozilla::RangeUpdater& mRU;
// Allow tracking either nsIDOMNode or nsINode until nsIDOMNode is gone
nsCOMPtr<nsINode>* mNode;
nsCOMPtr<nsIDOMNode>* mDOMNode;
int32_t* mOffset;
RefPtr<mozilla::RangeItem> mRangeItem;
public:
- nsAutoTrackDOMPoint(nsRangeUpdater &aRangeUpdater,
+ nsAutoTrackDOMPoint(mozilla::RangeUpdater& aRangeUpdater,
nsCOMPtr<nsINode>* aNode, int32_t* aOffset)
: mRU(aRangeUpdater)
, mNode(aNode)
, mDOMNode(nullptr)
, mOffset(aOffset)
{
mRangeItem = new mozilla::RangeItem();
mRangeItem->startNode = *mNode;
mRangeItem->endNode = *mNode;
mRangeItem->startOffset = *mOffset;
mRangeItem->endOffset = *mOffset;
mRU.RegisterRangeItem(mRangeItem);
}
- nsAutoTrackDOMPoint(nsRangeUpdater &aRangeUpdater,
+ nsAutoTrackDOMPoint(mozilla::RangeUpdater& aRangeUpdater,
nsCOMPtr<nsIDOMNode>* aNode, int32_t* aOffset)
: mRU(aRangeUpdater)
, mNode(nullptr)
, mDOMNode(aNode)
, mOffset(aOffset)
{
mRangeItem = new mozilla::RangeItem();
mRangeItem->startNode = do_QueryInterface(*mDOMNode);
@@ -233,22 +236,22 @@ class MOZ_STACK_CLASS nsAutoTrackDOMPoin
* Will/DidReplaceContainer()
*/
namespace mozilla {
namespace dom {
class MOZ_STACK_CLASS AutoReplaceContainerSelNotify
{
private:
- nsRangeUpdater &mRU;
+ RangeUpdater& mRU;
Element* mOriginalElement;
Element* mNewElement;
public:
- AutoReplaceContainerSelNotify(nsRangeUpdater& aRangeUpdater,
+ AutoReplaceContainerSelNotify(RangeUpdater& aRangeUpdater,
Element* aOriginalElement,
Element* aNewElement)
: mRU(aRangeUpdater)
, mOriginalElement(aOriginalElement)
, mNewElement(aNewElement)
{
mRU.WillReplaceContainer();
}
@@ -266,24 +269,24 @@ class MOZ_STACK_CLASS AutoReplaceContain
/***************************************************************************
* another helper class for SelectionState. stack based class for doing
* Will/DidRemoveContainer()
*/
class MOZ_STACK_CLASS nsAutoRemoveContainerSelNotify
{
private:
- nsRangeUpdater &mRU;
+ mozilla::RangeUpdater& mRU;
nsIDOMNode *mNode;
nsIDOMNode *mParent;
int32_t mOffset;
uint32_t mNodeOrigLen;
public:
- nsAutoRemoveContainerSelNotify(nsRangeUpdater& aRangeUpdater,
+ nsAutoRemoveContainerSelNotify(mozilla::RangeUpdater& aRangeUpdater,
nsINode* aNode,
nsINode* aParent,
int32_t aOffset,
uint32_t aNodeOrigLen)
: mRU(aRangeUpdater)
, mNode(aNode->AsDOMNode())
, mParent(aParent->AsDOMNode())
, mOffset(aOffset)
@@ -301,20 +304,21 @@ class MOZ_STACK_CLASS nsAutoRemoveContai
/***************************************************************************
* another helper class for SelectionState. stack based class for doing
* Will/DidInsertContainer()
*/
class MOZ_STACK_CLASS nsAutoInsertContainerSelNotify
{
private:
- nsRangeUpdater &mRU;
+ mozilla::RangeUpdater& mRU;
public:
- explicit nsAutoInsertContainerSelNotify(nsRangeUpdater &aRangeUpdater) :
+ explicit nsAutoInsertContainerSelNotify(
+ mozilla::RangeUpdater& aRangeUpdater) :
mRU(aRangeUpdater)
{
mRU.WillInsertContainer();
}
~nsAutoInsertContainerSelNotify()
{
mRU.DidInsertContainer();
@@ -325,24 +329,24 @@ class MOZ_STACK_CLASS nsAutoInsertContai
/***************************************************************************
* another helper class for SelectionState. stack based class for doing
* Will/DidMoveNode()
*/
class MOZ_STACK_CLASS nsAutoMoveNodeSelNotify
{
private:
- nsRangeUpdater &mRU;
+ mozilla::RangeUpdater& mRU;
nsINode* mOldParent;
nsINode* mNewParent;
int32_t mOldOffset;
int32_t mNewOffset;
public:
- nsAutoMoveNodeSelNotify(nsRangeUpdater &aRangeUpdater,
+ nsAutoMoveNodeSelNotify(mozilla::RangeUpdater& aRangeUpdater,
nsINode* aOldParent,
int32_t aOldOffset,
nsINode* aNewParent,
int32_t aNewOffset)
: mRU(aRangeUpdater)
, mOldParent(aOldParent)
, mNewParent(aNewParent)
, mOldOffset(aOldOffset)
--- a/editor/libeditor/nsEditor.h
+++ b/editor/libeditor/nsEditor.h
@@ -1,17 +1,17 @@
/* -*- 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/. */
#ifndef __editor_h__
#define __editor_h__
-#include "SelectionState.h" // for nsRangeUpdater, etc
+#include "SelectionState.h" // for RangeUpdater, etc
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc.
#include "mozilla/OwningNonNull.h" // for OwningNonNull
#include "mozilla/StyleSheetHandle.h" // for StyleSheetHandle
#include "mozilla/dom/Text.h"
#include "nsCOMPtr.h" // for already_AddRefed, nsCOMPtr
#include "nsCycleCollectionParticipant.h"
#include "nsGkAtoms.h"
#include "nsIEditor.h" // for nsIEditor::EDirection, etc
@@ -862,17 +862,18 @@ protected:
nsTArray<OwningNonNull<nsIEditActionListener>> mActionListeners;
// Just notify once per high level change
nsTArray<OwningNonNull<nsIEditorObserver>> mEditorObservers;
// Listen to overall doc state (dirty or not, just created, etc)
nsTArray<OwningNonNull<nsIDocumentStateListener>> mDocStateListeners;
// Cached selection for AutoSelectionRestorer.
mozilla::SelectionState mSavedSel;
- nsRangeUpdater mRangeUpdater; // utility class object for maintaining preserved ranges
+ // Utility class object for maintaining preserved ranges.
+ mozilla::RangeUpdater mRangeUpdater;
uint32_t mModCount; // number of modifications (for undo/redo stack)
uint32_t mFlags; // behavior flags. See nsIPlaintextEditor.idl for the flags we use.
int32_t mUpdateCount;
int32_t mPlaceHolderBatch; // nesting count for batching
EditAction mAction; // the current editor action
@@ -892,13 +893,13 @@ protected:
bool mDispatchInputEvent;
bool mIsInEditAction; // true while the instance is handling an edit action
bool mHidingCaret; // whether caret is hidden forcibly.
friend bool NSCanUnload(nsISupports* serviceMgr);
friend class mozilla::AutoRules;
friend class mozilla::AutoSelectionRestorer;
friend class mozilla::AutoTransactionsConserveSelection;
- friend class nsRangeUpdater;
+ friend class mozilla::RangeUpdater;
};
#endif
