2001-09-25 22:53:13 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
1999-08-09 01:34:04 +00:00
|
|
|
|
2016-07-08 05:03:31 +00:00
|
|
|
#ifndef mozilla_EditorUtils_h
|
|
|
|
#define mozilla_EditorUtils_h
|
1999-08-09 01:34:04 +00:00
|
|
|
|
2019-01-11 01:50:19 +00:00
|
|
|
#include "mozilla/ContentIterator.h"
|
2017-06-28 00:34:18 +00:00
|
|
|
#include "mozilla/dom/Selection.h"
|
2018-01-12 10:01:04 +00:00
|
|
|
#include "mozilla/EditAction.h"
|
2016-07-08 04:10:13 +00:00
|
|
|
#include "mozilla/EditorBase.h"
|
2017-11-06 08:01:33 +00:00
|
|
|
#include "mozilla/EditorDOMPoint.h"
|
2016-07-08 04:10:13 +00:00
|
|
|
#include "mozilla/GuardObjects.h"
|
2019-08-20 01:51:59 +00:00
|
|
|
#include "mozilla/RangeBoundary.h"
|
1999-08-09 01:34:04 +00:00
|
|
|
#include "nsCOMPtr.h"
|
2012-07-13 06:33:42 +00:00
|
|
|
#include "nsDebug.h"
|
1999-08-09 01:34:04 +00:00
|
|
|
#include "nsIEditor.h"
|
2012-07-13 06:33:42 +00:00
|
|
|
#include "nscore.h"
|
1999-12-07 08:30:19 +00:00
|
|
|
|
2017-10-02 22:05:19 +00:00
|
|
|
class nsAtom;
|
2016-06-23 07:59:15 +00:00
|
|
|
class nsISimpleEnumerator;
|
|
|
|
class nsITransferable;
|
2014-11-02 12:04:13 +00:00
|
|
|
class nsRange;
|
2016-06-23 09:51:19 +00:00
|
|
|
|
2014-11-02 12:04:13 +00:00
|
|
|
namespace mozilla {
|
2015-04-24 11:27:35 +00:00
|
|
|
template <class T>
|
|
|
|
class OwningNonNull;
|
2016-06-23 09:51:19 +00:00
|
|
|
|
2018-05-11 06:52:24 +00:00
|
|
|
namespace dom {
|
|
|
|
class Element;
|
|
|
|
class Text;
|
|
|
|
} // namespace dom
|
|
|
|
|
2016-11-18 08:59:23 +00:00
|
|
|
/***************************************************************************
|
|
|
|
* EditActionResult is useful to return multiple results of an editor
|
|
|
|
* action handler without out params.
|
|
|
|
* Note that when you return an anonymous instance from a method, you should
|
|
|
|
* use EditActionIgnored(), EditActionHandled() or EditActionCanceled() for
|
|
|
|
* easier to read. In other words, EditActionResult should be used when
|
|
|
|
* declaring return type of a method, being an argument or defined as a local
|
|
|
|
* variable.
|
|
|
|
*/
|
|
|
|
class MOZ_STACK_CLASS EditActionResult final {
|
|
|
|
public:
|
|
|
|
bool Succeeded() const { return NS_SUCCEEDED(mRv); }
|
|
|
|
bool Failed() const { return NS_FAILED(mRv); }
|
|
|
|
nsresult Rv() const { return mRv; }
|
|
|
|
bool Canceled() const { return mCanceled; }
|
|
|
|
bool Handled() const { return mHandled; }
|
2018-11-03 11:20:06 +00:00
|
|
|
bool Ignored() const { return !mCanceled && !mHandled; }
|
2018-04-24 06:23:01 +00:00
|
|
|
bool EditorDestroyed() const { return mRv == NS_ERROR_EDITOR_DESTROYED; }
|
2016-11-18 08:59:23 +00:00
|
|
|
|
|
|
|
EditActionResult SetResult(nsresult aRv) {
|
|
|
|
mRv = aRv;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
EditActionResult MarkAsCanceled() {
|
|
|
|
mCanceled = true;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
EditActionResult MarkAsHandled() {
|
|
|
|
mHandled = true;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit EditActionResult(nsresult aRv)
|
|
|
|
: mRv(aRv), mCanceled(false), mHandled(false) {}
|
|
|
|
|
|
|
|
EditActionResult& operator|=(const EditActionResult& aOther) {
|
|
|
|
mCanceled |= aOther.mCanceled;
|
|
|
|
mHandled |= aOther.mHandled;
|
|
|
|
// When both result are same, keep the result.
|
|
|
|
if (mRv == aOther.mRv) {
|
|
|
|
return *this;
|
|
|
|
}
|
2018-04-24 06:23:01 +00:00
|
|
|
// If one of the result is NS_ERROR_EDITOR_DESTROYED, use it since it's
|
|
|
|
// the most important error code for editor.
|
|
|
|
if (EditorDestroyed() || aOther.EditorDestroyed()) {
|
|
|
|
mRv = NS_ERROR_EDITOR_DESTROYED;
|
|
|
|
}
|
2016-11-18 08:59:23 +00:00
|
|
|
// If one of the results is error, use NS_ERROR_FAILURE.
|
2018-04-24 06:23:01 +00:00
|
|
|
else if (Failed() || aOther.Failed()) {
|
2016-11-18 08:59:23 +00:00
|
|
|
mRv = NS_ERROR_FAILURE;
|
|
|
|
} else {
|
|
|
|
// Otherwise, use generic success code, NS_OK.
|
|
|
|
mRv = NS_OK;
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
nsresult mRv;
|
|
|
|
bool mCanceled;
|
|
|
|
bool mHandled;
|
|
|
|
|
|
|
|
EditActionResult(nsresult aRv, bool aCanceled, bool aHandled)
|
|
|
|
: mRv(aRv), mCanceled(aCanceled), mHandled(aHandled) {}
|
|
|
|
|
|
|
|
EditActionResult()
|
|
|
|
: mRv(NS_ERROR_NOT_INITIALIZED), mCanceled(false), mHandled(false) {}
|
|
|
|
|
|
|
|
friend EditActionResult EditActionIgnored(nsresult aRv);
|
|
|
|
friend EditActionResult EditActionHandled(nsresult aRv);
|
|
|
|
friend EditActionResult EditActionCanceled(nsresult aRv);
|
|
|
|
};
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* When an edit action handler (or its helper) does nothing,
|
|
|
|
* EditActionIgnored should be returned.
|
|
|
|
*/
|
|
|
|
inline EditActionResult EditActionIgnored(nsresult aRv = NS_OK) {
|
|
|
|
return EditActionResult(aRv, false, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* When an edit action handler (or its helper) handled and not canceled,
|
|
|
|
* EditActionHandled should be returned.
|
|
|
|
*/
|
|
|
|
inline EditActionResult EditActionHandled(nsresult aRv = NS_OK) {
|
|
|
|
return EditActionResult(aRv, false, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
* When an edit action handler (or its helper) handled and canceled,
|
|
|
|
* EditActionHandled should be returned.
|
|
|
|
*/
|
|
|
|
inline EditActionResult EditActionCanceled(nsresult aRv = NS_OK) {
|
|
|
|
return EditActionResult(aRv, true, true);
|
|
|
|
}
|
|
|
|
|
2018-05-11 06:52:24 +00:00
|
|
|
/***************************************************************************
|
|
|
|
* CreateNodeResultBase is a simple class for CreateSomething() methods
|
|
|
|
* which want to return new node.
|
|
|
|
*/
|
|
|
|
template <typename NodeType>
|
|
|
|
class CreateNodeResultBase;
|
|
|
|
|
|
|
|
typedef CreateNodeResultBase<dom::Element> CreateElementResult;
|
|
|
|
|
|
|
|
template <typename NodeType>
|
|
|
|
class MOZ_STACK_CLASS CreateNodeResultBase final {
|
|
|
|
typedef CreateNodeResultBase<NodeType> SelfType;
|
2018-11-30 10:46:48 +00:00
|
|
|
|
2018-05-11 06:52:24 +00:00
|
|
|
public:
|
|
|
|
bool Succeeded() const { return NS_SUCCEEDED(mRv); }
|
|
|
|
bool Failed() const { return NS_FAILED(mRv); }
|
|
|
|
nsresult Rv() const { return mRv; }
|
|
|
|
NodeType* GetNewNode() const { return mNode; }
|
|
|
|
|
|
|
|
CreateNodeResultBase() = delete;
|
|
|
|
|
|
|
|
explicit CreateNodeResultBase(nsresult aRv) : mRv(aRv) {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(NS_FAILED(mRv));
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit CreateNodeResultBase(NodeType* aNode)
|
|
|
|
: mNode(aNode), mRv(aNode ? NS_OK : NS_ERROR_FAILURE) {}
|
|
|
|
|
|
|
|
explicit CreateNodeResultBase(already_AddRefed<NodeType>&& aNode)
|
|
|
|
: mNode(aNode), mRv(mNode.get() ? NS_OK : NS_ERROR_FAILURE) {}
|
|
|
|
|
|
|
|
CreateNodeResultBase(const SelfType& aOther) = delete;
|
|
|
|
SelfType& operator=(const SelfType& aOther) = delete;
|
|
|
|
CreateNodeResultBase(SelfType&& aOther) = default;
|
|
|
|
SelfType& operator=(SelfType&& aOther) = default;
|
|
|
|
|
|
|
|
already_AddRefed<NodeType> forget() {
|
|
|
|
mRv = NS_ERROR_NOT_INITIALIZED;
|
|
|
|
return mNode.forget();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
RefPtr<NodeType> mNode;
|
|
|
|
nsresult mRv;
|
|
|
|
};
|
|
|
|
|
2017-11-16 03:09:57 +00:00
|
|
|
/***************************************************************************
|
2018-04-09 17:16:49 +00:00
|
|
|
* SplitNodeResult is a simple class for
|
|
|
|
* EditorBase::SplitNodeDeepWithTransaction().
|
2017-11-16 03:09:57 +00:00
|
|
|
* This makes the callers' code easier to read.
|
|
|
|
*/
|
|
|
|
class MOZ_STACK_CLASS SplitNodeResult final {
|
|
|
|
public:
|
|
|
|
bool Succeeded() const { return NS_SUCCEEDED(mRv); }
|
|
|
|
bool Failed() const { return NS_FAILED(mRv); }
|
|
|
|
nsresult Rv() const { return mRv; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* DidSplit() returns true if a node was actually split.
|
|
|
|
*/
|
|
|
|
bool DidSplit() const { return mPreviousNode && mNextNode; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GetLeftNode() simply returns the left node which was created at splitting.
|
|
|
|
* This returns nullptr if the node wasn't split.
|
|
|
|
*/
|
|
|
|
nsIContent* GetLeftNode() const {
|
|
|
|
return mPreviousNode && mNextNode ? mPreviousNode.get() : nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GetRightNode() simply returns the right node which was split.
|
|
|
|
* This won't return nullptr unless failed to split due to invalid arguments.
|
|
|
|
*/
|
|
|
|
nsIContent* GetRightNode() const {
|
2017-11-19 02:05:26 +00:00
|
|
|
if (mGivenSplitPoint.IsSet()) {
|
2017-12-07 10:08:56 +00:00
|
|
|
return mGivenSplitPoint.GetChild();
|
2017-11-19 02:05:26 +00:00
|
|
|
}
|
2017-11-16 03:09:57 +00:00
|
|
|
return mPreviousNode && !mNextNode ? mPreviousNode : mNextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GetPreviousNode() returns previous node at the split point.
|
|
|
|
*/
|
2017-11-19 02:05:26 +00:00
|
|
|
nsIContent* GetPreviousNode() const {
|
|
|
|
if (mGivenSplitPoint.IsSet()) {
|
|
|
|
return mGivenSplitPoint.IsEndOfContainer() ? mGivenSplitPoint.GetChild()
|
2017-12-07 10:08:56 +00:00
|
|
|
: nullptr;
|
2017-11-19 02:05:26 +00:00
|
|
|
}
|
|
|
|
return mPreviousNode;
|
|
|
|
}
|
2017-11-16 03:09:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* GetNextNode() returns next node at the split point.
|
|
|
|
*/
|
2017-11-19 02:05:26 +00:00
|
|
|
nsIContent* GetNextNode() const {
|
|
|
|
if (mGivenSplitPoint.IsSet()) {
|
|
|
|
return !mGivenSplitPoint.IsEndOfContainer() ? mGivenSplitPoint.GetChild()
|
2017-12-07 10:08:56 +00:00
|
|
|
: nullptr;
|
2017-11-19 02:05:26 +00:00
|
|
|
}
|
|
|
|
return mNextNode;
|
|
|
|
}
|
2017-11-16 03:09:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* SplitPoint() returns the split point in the container.
|
|
|
|
* This is useful when callers insert an element at split point with
|
2018-04-09 16:17:26 +00:00
|
|
|
* EditorBase::CreateNodeWithTransaction() or something similar methods.
|
2017-11-16 03:09:57 +00:00
|
|
|
*
|
|
|
|
* Note that the result is EditorRawDOMPoint but the nodes are grabbed
|
|
|
|
* by this instance. Therefore, the life time of both container node
|
|
|
|
* and child node are guaranteed while using the result temporarily.
|
|
|
|
*/
|
2019-05-08 09:40:17 +00:00
|
|
|
EditorDOMPoint SplitPoint() const {
|
2017-11-16 03:09:57 +00:00
|
|
|
if (Failed()) {
|
2019-05-08 09:40:17 +00:00
|
|
|
return EditorDOMPoint();
|
2017-11-16 03:09:57 +00:00
|
|
|
}
|
2017-11-19 02:05:26 +00:00
|
|
|
if (mGivenSplitPoint.IsSet()) {
|
2019-05-08 09:40:17 +00:00
|
|
|
return EditorDOMPoint(mGivenSplitPoint);
|
2017-11-19 02:05:26 +00:00
|
|
|
}
|
2017-11-16 03:09:57 +00:00
|
|
|
if (!mPreviousNode) {
|
2019-05-08 09:40:17 +00:00
|
|
|
return EditorDOMPoint(mNextNode);
|
2017-11-16 03:09:57 +00:00
|
|
|
}
|
2019-05-08 09:40:17 +00:00
|
|
|
EditorDOMPoint point(mPreviousNode);
|
2017-11-16 03:09:57 +00:00
|
|
|
DebugOnly<bool> advanced = point.AdvanceOffset();
|
|
|
|
NS_WARNING_ASSERTION(advanced,
|
|
|
|
"Failed to advance offset to after previous node");
|
|
|
|
return point;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This constructor shouldn't be used by anybody except methods which
|
|
|
|
* use this as result when it succeeds.
|
|
|
|
*
|
|
|
|
* @param aPreviousNodeOfSplitPoint Previous node immediately before
|
|
|
|
* split point.
|
|
|
|
* @param aNextNodeOfSplitPoint Next node immediately after split
|
|
|
|
* point.
|
|
|
|
*/
|
|
|
|
SplitNodeResult(nsIContent* aPreviousNodeOfSplitPoint,
|
|
|
|
nsIContent* aNextNodeOfSplitPoint)
|
|
|
|
: mPreviousNode(aPreviousNodeOfSplitPoint),
|
|
|
|
mNextNode(aNextNodeOfSplitPoint),
|
|
|
|
mRv(NS_OK) {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mPreviousNode || mNextNode);
|
|
|
|
}
|
|
|
|
|
2017-11-19 02:05:26 +00:00
|
|
|
/**
|
|
|
|
* This constructor should be used when the method didn't split any nodes
|
|
|
|
* but want to return given split point as right point.
|
|
|
|
*/
|
|
|
|
explicit SplitNodeResult(const EditorRawDOMPoint& aGivenSplitPoint)
|
|
|
|
: mGivenSplitPoint(aGivenSplitPoint), mRv(NS_OK) {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mGivenSplitPoint.IsSet());
|
|
|
|
}
|
|
|
|
|
2017-11-16 03:09:57 +00:00
|
|
|
/**
|
|
|
|
* This constructor shouldn't be used by anybody except methods which
|
|
|
|
* use this as error result when it fails.
|
|
|
|
*/
|
|
|
|
explicit SplitNodeResult(nsresult aRv) : mRv(aRv) {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(NS_FAILED(mRv));
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2017-11-19 02:05:26 +00:00
|
|
|
// When methods which return this class split some nodes actually, they
|
|
|
|
// need to set a set of left node and right node to this class. However,
|
|
|
|
// one or both of them may be moved or removed by mutation observer.
|
|
|
|
// In such case, we cannot represent the point with EditorDOMPoint since
|
|
|
|
// it requires current container node. Therefore, we need to use
|
|
|
|
// nsCOMPtr<nsIContent> here instead.
|
2017-11-16 03:09:57 +00:00
|
|
|
nsCOMPtr<nsIContent> mPreviousNode;
|
|
|
|
nsCOMPtr<nsIContent> mNextNode;
|
|
|
|
|
2017-11-19 02:05:26 +00:00
|
|
|
// Methods which return this class may not split any nodes actually. Then,
|
|
|
|
// they may want to return given split point as is since such behavior makes
|
|
|
|
// their callers simpler. In this case, the point may be in a text node
|
|
|
|
// which cannot be represented as a node. Therefore, we need EditorDOMPoint
|
|
|
|
// for representing the point.
|
|
|
|
EditorDOMPoint mGivenSplitPoint;
|
|
|
|
|
2017-11-16 03:09:57 +00:00
|
|
|
nsresult mRv;
|
|
|
|
|
|
|
|
SplitNodeResult() = delete;
|
|
|
|
};
|
|
|
|
|
2018-05-17 07:28:52 +00:00
|
|
|
/***************************************************************************
|
|
|
|
* SplitRangeOffFromNodeResult class is a simple class for methods which split a
|
|
|
|
* node at 2 points for making part of the node split off from the node.
|
|
|
|
*/
|
|
|
|
class MOZ_STACK_CLASS SplitRangeOffFromNodeResult final {
|
|
|
|
public:
|
|
|
|
bool Succeeded() const { return NS_SUCCEEDED(mRv); }
|
|
|
|
bool Failed() const { return NS_FAILED(mRv); }
|
|
|
|
nsresult Rv() const { return mRv; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GetLeftContent() returns new created node before the part of quarried out.
|
|
|
|
* This may return nullptr if the method didn't split at start edge of
|
|
|
|
* the node.
|
|
|
|
*/
|
|
|
|
nsIContent* GetLeftContent() const { return mLeftContent; }
|
|
|
|
dom::Element* GetLeftContentAsElement() const {
|
2018-05-30 14:56:24 +00:00
|
|
|
return Element::FromNodeOrNull(mLeftContent);
|
2018-05-17 07:28:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GetMiddleContent() returns new created node between left node and right
|
|
|
|
* node. I.e., this is quarried out from the node. This may return nullptr
|
|
|
|
* if the method unwrapped the middle node.
|
|
|
|
*/
|
|
|
|
nsIContent* GetMiddleContent() const { return mMiddleContent; }
|
|
|
|
dom::Element* GetMiddleContentAsElement() const {
|
2018-05-30 14:56:24 +00:00
|
|
|
return Element::FromNodeOrNull(mMiddleContent);
|
2018-05-17 07:28:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* GetRightContent() returns the right node after the part of quarried out.
|
|
|
|
* This may return nullptr it the method didn't split at end edge of the
|
|
|
|
* node.
|
|
|
|
*/
|
|
|
|
nsIContent* GetRightContent() const { return mRightContent; }
|
|
|
|
dom::Element* GetRightContentAsElement() const {
|
2018-05-30 14:56:24 +00:00
|
|
|
return Element::FromNodeOrNull(mRightContent);
|
2018-05-17 07:28:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SplitRangeOffFromNodeResult(nsIContent* aLeftContent,
|
|
|
|
nsIContent* aMiddleContent,
|
|
|
|
nsIContent* aRightContent)
|
|
|
|
: mLeftContent(aLeftContent),
|
|
|
|
mMiddleContent(aMiddleContent),
|
|
|
|
mRightContent(aRightContent),
|
|
|
|
mRv(NS_OK) {}
|
|
|
|
|
|
|
|
SplitRangeOffFromNodeResult(SplitNodeResult& aSplitResultAtLeftOfMiddleNode,
|
|
|
|
SplitNodeResult& aSplitResultAtRightOfMiddleNode)
|
|
|
|
: mRv(NS_OK) {
|
|
|
|
if (aSplitResultAtLeftOfMiddleNode.Succeeded()) {
|
|
|
|
mLeftContent = aSplitResultAtLeftOfMiddleNode.GetPreviousNode();
|
|
|
|
}
|
|
|
|
if (aSplitResultAtRightOfMiddleNode.Succeeded()) {
|
|
|
|
mRightContent = aSplitResultAtRightOfMiddleNode.GetNextNode();
|
|
|
|
mMiddleContent = aSplitResultAtRightOfMiddleNode.GetPreviousNode();
|
|
|
|
}
|
|
|
|
if (!mMiddleContent && aSplitResultAtLeftOfMiddleNode.Succeeded()) {
|
|
|
|
mMiddleContent = aSplitResultAtLeftOfMiddleNode.GetNextNode();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit SplitRangeOffFromNodeResult(nsresult aRv) : mRv(aRv) {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(NS_FAILED(mRv));
|
|
|
|
}
|
|
|
|
|
|
|
|
SplitRangeOffFromNodeResult(const SplitRangeOffFromNodeResult& aOther) =
|
2018-11-30 10:46:48 +00:00
|
|
|
delete;
|
2018-05-17 07:28:52 +00:00
|
|
|
SplitRangeOffFromNodeResult& operator=(
|
|
|
|
const SplitRangeOffFromNodeResult& aOther) = delete;
|
|
|
|
SplitRangeOffFromNodeResult(SplitRangeOffFromNodeResult&& aOther) = default;
|
|
|
|
SplitRangeOffFromNodeResult& operator=(SplitRangeOffFromNodeResult&& aOther) =
|
|
|
|
default;
|
|
|
|
|
|
|
|
private:
|
|
|
|
nsCOMPtr<nsIContent> mLeftContent;
|
|
|
|
nsCOMPtr<nsIContent> mMiddleContent;
|
|
|
|
nsCOMPtr<nsIContent> mRightContent;
|
|
|
|
|
|
|
|
nsresult mRv;
|
|
|
|
|
|
|
|
SplitRangeOffFromNodeResult() = delete;
|
|
|
|
};
|
|
|
|
|
2018-10-24 05:18:40 +00:00
|
|
|
/***************************************************************************
|
|
|
|
* stack based helper class for calling EditorBase::EndTransaction() after
|
|
|
|
* EditorBase::BeginTransaction(). This shouldn't be used in editor classes
|
|
|
|
* or helper classes while an edit action is being handled. Use
|
|
|
|
* AutoTransactionBatch in such cases since it uses non-virtual internal
|
|
|
|
* methods.
|
|
|
|
***************************************************************************/
|
|
|
|
class MOZ_RAII AutoTransactionBatchExternal final {
|
|
|
|
public:
|
2019-05-09 07:37:51 +00:00
|
|
|
MOZ_CAN_RUN_SCRIPT explicit AutoTransactionBatchExternal(
|
2018-10-24 05:18:40 +00:00
|
|
|
EditorBase& aEditorBase MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
|
|
|
|
: mEditorBase(aEditorBase) {
|
|
|
|
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
2019-05-09 07:37:51 +00:00
|
|
|
mEditorBase.BeginTransaction();
|
2018-10-24 05:18:40 +00:00
|
|
|
}
|
|
|
|
|
2019-05-09 07:37:51 +00:00
|
|
|
MOZ_CAN_RUN_SCRIPT ~AutoTransactionBatchExternal() {
|
|
|
|
MOZ_KnownLive(mEditorBase).EndTransaction();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
EditorBase& mEditorBase;
|
|
|
|
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
|
2018-10-24 05:18:40 +00:00
|
|
|
};
|
|
|
|
|
2017-06-28 00:34:18 +00:00
|
|
|
class MOZ_STACK_CLASS AutoRangeArray final {
|
|
|
|
public:
|
|
|
|
explicit AutoRangeArray(dom::Selection* aSelection) {
|
|
|
|
if (!aSelection) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
uint32_t rangeCount = aSelection->RangeCount();
|
|
|
|
for (uint32_t i = 0; i < rangeCount; i++) {
|
|
|
|
mRanges.AppendElement(*aSelection->GetRangeAt(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
AutoTArray<mozilla::OwningNonNull<nsRange>, 8> mRanges;
|
|
|
|
};
|
|
|
|
|
2000-08-26 04:03:50 +00:00
|
|
|
/******************************************************************************
|
|
|
|
* some helper classes for iterating the dom tree
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2016-06-23 08:39:47 +00:00
|
|
|
class BoolDomIterFunctor {
|
|
|
|
public:
|
|
|
|
virtual bool operator()(nsINode* aNode) const = 0;
|
2000-08-26 04:03:50 +00:00
|
|
|
};
|
|
|
|
|
2016-06-23 08:30:39 +00:00
|
|
|
class MOZ_RAII DOMIterator {
|
|
|
|
public:
|
|
|
|
explicit DOMIterator(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM);
|
2015-05-22 13:58:30 +00:00
|
|
|
|
2016-06-23 08:30:39 +00:00
|
|
|
explicit DOMIterator(nsINode& aNode MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
|
2019-01-11 01:52:26 +00:00
|
|
|
virtual ~DOMIterator() = default;
|
2015-04-24 11:27:34 +00:00
|
|
|
|
2016-06-23 08:30:39 +00:00
|
|
|
nsresult Init(nsRange& aRange);
|
2019-08-20 01:51:59 +00:00
|
|
|
nsresult Init(const RawRangeBoundary& aStartRef,
|
|
|
|
const RawRangeBoundary& aEndRef);
|
2015-05-22 13:58:30 +00:00
|
|
|
|
2016-06-23 08:30:39 +00:00
|
|
|
void AppendList(
|
2016-06-23 08:39:47 +00:00
|
|
|
const BoolDomIterFunctor& functor,
|
2016-06-23 08:30:39 +00:00
|
|
|
nsTArray<mozilla::OwningNonNull<nsINode>>& arrayOfNodes) const;
|
2000-08-26 04:03:50 +00:00
|
|
|
|
2016-06-23 08:30:39 +00:00
|
|
|
protected:
|
2019-01-11 01:52:26 +00:00
|
|
|
ContentIteratorBase* mIter;
|
|
|
|
PostContentIterator mPostOrderIter;
|
2016-06-23 08:30:39 +00:00
|
|
|
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
|
|
|
|
};
|
2016-06-23 08:25:03 +00:00
|
|
|
|
2016-06-23 08:30:39 +00:00
|
|
|
class MOZ_RAII DOMSubtreeIterator final : public DOMIterator {
|
2016-06-23 08:25:03 +00:00
|
|
|
public:
|
|
|
|
explicit DOMSubtreeIterator(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM);
|
2019-01-11 01:52:26 +00:00
|
|
|
virtual ~DOMSubtreeIterator() = default;
|
2015-05-22 13:58:30 +00:00
|
|
|
|
2016-06-23 08:25:03 +00:00
|
|
|
nsresult Init(nsRange& aRange);
|
2019-01-11 01:52:26 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
ContentSubtreeIterator mSubtreeIter;
|
|
|
|
explicit DOMSubtreeIterator(nsINode& aNode MOZ_GUARD_OBJECT_NOTIFIER_PARAM) =
|
|
|
|
delete;
|
2000-08-26 04:03:50 +00:00
|
|
|
};
|
2000-01-04 03:09:41 +00:00
|
|
|
|
2016-06-23 08:39:47 +00:00
|
|
|
class TrivialFunctor final : public BoolDomIterFunctor {
|
2016-06-23 08:19:35 +00:00
|
|
|
public:
|
|
|
|
// Used to build list of all nodes iterator covers
|
2017-11-06 03:37:28 +00:00
|
|
|
virtual bool operator()(nsINode* aNode) const override { return true; }
|
Checking in for bug 50742, this change removes the use of XIF in mozilla and replaces the XIF converter with a HTML (and XML) serializer.
Contextual information added to HTML copy and intelligence added to HTML paste in the editor (fixes bugs 47014, 50568 and 46554, and partly (at least) fixes bug 53188).
Code written by vidur, jfrancis, jst, akkana. Tested by jfrancis, akkana, vidur, jst, kin. Reviwed (and super reviewed) by waterson, vidur, kin, jfrancis, jst
2000-10-07 10:57:30 +00:00
|
|
|
};
|
|
|
|
|
2016-07-07 02:49:42 +00:00
|
|
|
class EditorUtils final {
|
|
|
|
public:
|
2017-11-06 08:01:33 +00:00
|
|
|
/**
|
|
|
|
* IsDescendantOf() checks if aNode is a child or a descendant of aParent.
|
|
|
|
* aOutPoint is set to the child of aParent.
|
|
|
|
*
|
|
|
|
* @return true if aNode is a child or a descendant of aParent.
|
|
|
|
*/
|
|
|
|
static bool IsDescendantOf(const nsINode& aNode, const nsINode& aParent,
|
|
|
|
EditorRawDOMPoint* aOutPoint = nullptr);
|
|
|
|
static bool IsDescendantOf(const nsINode& aNode, const nsINode& aParent,
|
|
|
|
EditorDOMPoint* aOutPoint);
|
2019-07-29 06:21:42 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Helper method for `AppendString()` and `AppendSubString()`. This should
|
|
|
|
* be called only when `aText` is in a password field. This method masks
|
|
|
|
* A part of or all of `aText` (`aStartOffsetInText` and later) should've
|
|
|
|
* been copied (apppended) to `aString`. `aStartOffsetInString` is where
|
|
|
|
* the password was appended into `aString`.
|
|
|
|
*/
|
|
|
|
static void MaskString(nsString& aString, dom::Text* aText,
|
|
|
|
uint32_t aStartOffsetInString,
|
|
|
|
uint32_t aStartOffsetInText);
|
2002-12-22 01:51:14 +00:00
|
|
|
};
|
|
|
|
|
2016-06-23 07:59:15 +00:00
|
|
|
} // namespace mozilla
|
|
|
|
|
2016-07-08 05:03:31 +00:00
|
|
|
#endif // #ifndef mozilla_EditorUtils_h
|