element. + constexpr HTMLEditUtils::WalkTreeOptions + ignoreNonEditableNodeAndStopAtBlockBoundary{ + HTMLEditUtils::WalkTreeOption::IgnoreNonEditableNode, + HTMLEditUtils::WalkTreeOption::StopAtBlockBoundary}; + for (nsIContent* nextEditableContent = HTMLEditUtils::GetNextContent( + point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost); + nextEditableContent && + !HTMLEditUtils::IsBlockElement(*nextEditableContent) && + nextEditableContent->GetParent(); + nextEditableContent = HTMLEditUtils::GetNextContent( + point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost)) { + EditorDOMPoint atFirstPreformattedNewLine = + HTMLEditUtils::GetInclusiveNextPreformattedNewLineInTextNode< + EditorDOMPoint>(EditorRawDOMPoint(nextEditableContent, 0)); + if (atFirstPreformattedNewLine.IsSet()) { + // If the linefeed is last character of the text node, it may be + // invisible if it's immediately before a block boundary. In such + // case, we should retrun the block boundary. + Element* maybeNonEditableBlockElement = nullptr; + if (HTMLEditUtils::IsInvisiblePreformattedNewLine( + atFirstPreformattedNewLine, &maybeNonEditableBlockElement) && + maybeNonEditableBlockElement) { + // If the block is a parent of the editing host, let's return end + // of editing host. + if (maybeNonEditableBlockElement == &aEditingHost || + !maybeNonEditableBlockElement->IsInclusiveDescendantOf( + &aEditingHost)) { + return EditorDOMPoint::AtEndOf(*maybeNonEditableBlockElement); + } + // If it's invisible because of parent block boundary, return end + // of the block. Otherwise, i.e., it's followed by a child block, + // returns the point of the child block. + if (atFirstPreformattedNewLine.ContainerAs() + ->IsInclusiveDescendantOf(maybeNonEditableBlockElement)) { + return EditorDOMPoint::AtEndOf(*maybeNonEditableBlockElement); + } + return EditorDOMPoint(maybeNonEditableBlockElement); + } + // Otherwise, return the point after the preformatted linefeed. + return atFirstPreformattedNewLine.NextPoint(); + } + point.SetAfter(nextEditableContent); + if (NS_WARN_IF(!point.IsSet())) { + break; + } + if (HTMLEditUtils::IsVisibleBRElement(*nextEditableContent)) { + break; + } + } + + // Finding the real end for this point unless current line ends with a
+ // element. Look up the tree for as long as we are the last node in the + // container (typically, block node), and as long as we haven't hit the body + // node. + for (nsIContent* nearContent = HTMLEditUtils::GetNextContent( + point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost); + !nearContent && !point.IsContainerHTMLElement(nsGkAtoms::body) && + point.GetContainerParent(); + nearContent = HTMLEditUtils::GetNextContent( + point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost)) { + // Don't walk past the editable section. Note that we need to check before + // walking up to a parent because we need to return the parent object, so + // the parent itself might not be in the editable area, but it's OK. + // XXX Maybe returning parent of editing host is really error prone since + // everybody need to check whether the end point is in editing host + // when they touch there. + if (!point.GetContainer()->IsInclusiveDescendantOf(&aEditingHost) && + !point.GetContainerParent()->IsInclusiveDescendantOf(&aEditingHost)) { + break; + } + + point.SetAfter(point.GetContainer()); + if (NS_WARN_IF(!point.IsSet())) { + break; + } + } + return point; +} + +void AutoRangeArray::ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction aEditSubAction, const Element& aEditingHost) { + // FYI: This is originated in + // https://searchfox.org/mozilla-central/rev/1739f1301d658c9bff544a0a095ab11fca2e549d/editor/libeditor/HTMLEditSubActionHandler.cpp#6712 + + bool removeSomeRanges = false; + for (OwningNonNull& range : mRanges) { + // Remove non-positioned ranges. + if (MOZ_UNLIKELY(!range->IsPositioned())) { + removeSomeRanges = true; + continue; + } + // If the range is native anonymous subtrees, we must meet a bug of + // `Selection` so that we need to hack here. + if (MOZ_UNLIKELY(range->GetStartContainer()->IsInNativeAnonymousSubtree() || + range->GetEndContainer()->IsInNativeAnonymousSubtree())) { + EditorRawDOMRange rawRange(range); + if (!rawRange.EnsureNotInNativeAnonymousSubtree()) { + range->Reset(); + removeSomeRanges = true; + continue; + } + if (NS_FAILED( + range->SetStartAndEnd(rawRange.StartRef().ToRawRangeBoundary(), + rawRange.EndRef().ToRawRangeBoundary())) || + MOZ_UNLIKELY(!range->IsPositioned())) { + range->Reset(); + removeSomeRanges = true; + continue; + } + } + // Finally, extend the range. + if (NS_FAILED(ExtendRangeToWrapStartAndEndLinesContainingBoundaries( + range, aEditSubAction, aEditingHost))) { + // If we failed to extend the range, we should use the original range + // as-is unless the range is broken at setting the range. + if (NS_WARN_IF(!range->IsPositioned())) { + removeSomeRanges = true; + } + } + } + if (removeSomeRanges) { + for (size_t i : Reversed(IntegerRange(mRanges.Length()))) { + if (!mRanges[i]->IsPositioned()) { + mRanges.RemoveElementAt(i); + } + } + if (!mAnchorFocusRange || !mAnchorFocusRange->IsPositioned()) { + if (mRanges.IsEmpty()) { + mAnchorFocusRange = nullptr; + } else { + mAnchorFocusRange = mRanges.LastElement(); + } + } + } +} + +// static +nsresult AutoRangeArray::ExtendRangeToWrapStartAndEndLinesContainingBoundaries( + nsRange& aRange, EditSubAction aEditSubAction, + const Element& aEditingHost) { + MOZ_DIAGNOSTIC_ASSERT( + !EditorRawDOMPoint(aRange.StartRef()).IsInNativeAnonymousSubtree()); + MOZ_DIAGNOSTIC_ASSERT( + !EditorRawDOMPoint(aRange.EndRef()).IsInNativeAnonymousSubtree()); + + if (NS_WARN_IF(!aRange.IsPositioned())) { + return NS_ERROR_INVALID_ARG; + } + + EditorDOMPoint startPoint(aRange.StartRef()), endPoint(aRange.EndRef()); + AutoRangeArray::UpdatePointsToSelectAllChildrenIfCollapsedInEmptyBlockElement( + startPoint, endPoint, aEditingHost); + + // Make a new adjusted range to represent the appropriate block content. + // This is tricky. The basic idea is to push out the range endpoints to + // truly enclose the blocks that we will affect. + + // Make sure that the new range ends up to be in the editable section. + // XXX Looks like that this check wastes the time. Perhaps, we should + // implement a method which checks both two DOM points in the editor + // root. + + startPoint = GetPointAtFirstContentOfLineOrParentBlockIfFirstContentOfBlock( + startPoint, aEditSubAction, aEditingHost); + // XXX GetPointAtFirstContentOfLineOrParentBlockIfFirstContentOfBlock() may + // return point of editing host. Perhaps, we should change it and stop + // checking it here since this check may be expensive. + // XXX If the container is an element in the editing host but it points end of + // the container, this returns nullptr. Is it intentional? + if (!startPoint.GetChildOrContainerIfDataNode() || + !startPoint.GetChildOrContainerIfDataNode()->IsInclusiveDescendantOf( + &aEditingHost)) { + return NS_ERROR_FAILURE; + } + endPoint = + GetPointAfterFollowingLineBreakOrAtFollowingBlock(endPoint, aEditingHost); + const EditorDOMPoint lastRawPoint = + endPoint.IsStartOfContainer() ? endPoint : endPoint.PreviousPoint(); + // XXX GetPointAfterFollowingLineBreakOrAtFollowingBlock() may return point of + // editing host. Perhaps, we should change it and stop checking it here + // since this check may be expensive. + // XXX If the container is an element in the editing host but it points end of + // the container, this returns nullptr. Is it intentional? + if (!lastRawPoint.GetChildOrContainerIfDataNode() || + !lastRawPoint.GetChildOrContainerIfDataNode()->IsInclusiveDescendantOf( + &aEditingHost)) { + return NS_ERROR_FAILURE; + } + + nsresult rv = aRange.SetStartAndEnd(startPoint.ToRawRangeBoundary(), + endPoint.ToRawRangeBoundary()); + if (NS_FAILED(rv)) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +Result +AutoRangeArray::SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + HTMLEditor& aHTMLEditor, const Element& aEditingHost, + const nsIContent* aAncestorLimiter /* = nullptr */) { + // FYI: The following code is originated in + // https://searchfox.org/mozilla-central/rev/c8e15e17bc6fd28f558c395c948a6251b38774ff/editor/libeditor/HTMLEditSubActionHandler.cpp#6971 + + // Split text nodes. This is necessary, since given ranges may end in text + // nodes in case where part of a pre-formatted elements needs to be moved. + EditorDOMPoint pointToPutCaret; + IgnoredErrorResult ignoredError; + for (const OwningNonNull& range : mRanges) { + EditorDOMPoint atEnd(range->EndRef()); + if (NS_WARN_IF(!atEnd.IsSet()) || !atEnd.IsInTextNode() || + atEnd.GetContainer() == aAncestorLimiter) { + continue; + } + + if (!atEnd.IsStartOfContainer() && !atEnd.IsEndOfContainer()) { + // Split the text node. + Result splitAtEndResult = + aHTMLEditor.SplitNodeWithTransaction(atEnd); + if (MOZ_UNLIKELY(splitAtEndResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeWithTransaction() failed"); + return splitAtEndResult.propagateErr(); + } + SplitNodeResult unwrappedSplitAtEndResult = splitAtEndResult.unwrap(); + unwrappedSplitAtEndResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + + // Correct the range. + // The new end parent becomes the parent node of the text. + MOZ_ASSERT(!range->IsInAnySelection()); + range->SetEnd(unwrappedSplitAtEndResult.AtNextContent() + .ToRawRangeBoundary(), + ignoredError); + NS_WARNING_ASSERTION(!ignoredError.Failed(), + "nsRange::SetEnd() failed, but ignored"); + ignoredError.SuppressException(); + } + } + + // FYI: The following code is originated in + // https://searchfox.org/mozilla-central/rev/c8e15e17bc6fd28f558c395c948a6251b38774ff/editor/libeditor/HTMLEditSubActionHandler.cpp#7023 + AutoTArray, 8> rangeItemArray; + rangeItemArray.AppendElements(mRanges.Length()); + + // First register ranges for special editor gravity + Maybe anchorFocusRangeIndex; + for (size_t index : IntegerRange(rangeItemArray.Length())) { + rangeItemArray[index] = new RangeItem(); + rangeItemArray[index]->StoreRange(*mRanges[index]); + aHTMLEditor.RangeUpdaterRef().RegisterRangeItem(*rangeItemArray[index]); + if (mRanges[index] == mAnchorFocusRange) { + anchorFocusRangeIndex = Some(index); + } + } + // TODO: We should keep the array, and just update the ranges. + mRanges.Clear(); + mAnchorFocusRange = nullptr; + // Now bust up inlines. + nsresult rv = NS_OK; + for (OwningNonNull& item : Reversed(rangeItemArray)) { + // MOZ_KnownLive because 'rangeItemArray' is guaranteed to keep it alive. + Result splitParentsResult = + aHTMLEditor.SplitParentInlineElementsAtRangeBoundaries( + MOZ_KnownLive(*item), aEditingHost, aAncestorLimiter); + if (MOZ_UNLIKELY(splitParentsResult.isErr())) { + NS_WARNING( + "HTMLEditor::SplitParentInlineElementsAtRangeBoundaries() failed"); + rv = splitParentsResult.unwrapErr(); + break; + } + if (splitParentsResult.inspect().IsSet()) { + pointToPutCaret = splitParentsResult.unwrap(); + } + } + // Then unregister the ranges + for (size_t index : IntegerRange(rangeItemArray.Length())) { + aHTMLEditor.RangeUpdaterRef().DropRangeItem(rangeItemArray[index]); + RefPtr range = rangeItemArray[index]->GetRange(); + if (range && range->IsPositioned()) { + if (anchorFocusRangeIndex.isSome() && index == *anchorFocusRangeIndex) { + mAnchorFocusRange = range; + } + mRanges.AppendElement(std::move(range)); + } + } + if (!mAnchorFocusRange && !mRanges.IsEmpty()) { + mAnchorFocusRange = mRanges.LastElement(); + } + + // XXX Why do we ignore the other errors here?? + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + return pointToPutCaret; +} + +nsresult AutoRangeArray::CollectEditTargetNodes( + const HTMLEditor& aHTMLEditor, + nsTArray>& aOutArrayOfContents, + EditSubAction aEditSubAction, + CollectNonEditableNodes aCollectNonEditableNodes) const { + MOZ_ASSERT(aHTMLEditor.IsEditActionDataAvailable()); + + // FYI: This was moved from + // https://searchfox.org/mozilla-central/rev/4bce7d85ba4796dd03c5dcc7cfe8eee0e4c07b3b/editor/libeditor/HTMLEditSubActionHandler.cpp#7060 + + // Gather up a list of all the nodes + for (const OwningNonNull& range : mRanges) { + DOMSubtreeIterator iter; + nsresult rv = iter.Init(*range); + if (NS_FAILED(rv)) { + NS_WARNING("DOMSubtreeIterator::Init() failed"); + return rv; + } + if (aOutArrayOfContents.IsEmpty()) { + iter.AppendAllNodesToArray(aOutArrayOfContents); + } else { + AutoTArray, 24> arrayOfTopChildren; + iter.AppendNodesToArray( + +[](nsINode& aNode, void* aArray) -> bool { + MOZ_ASSERT(aArray); + return !static_cast>*>(aArray) + ->Contains(&aNode); + }, + arrayOfTopChildren, &aOutArrayOfContents); + aOutArrayOfContents.AppendElements(std::move(arrayOfTopChildren)); + } + if (aCollectNonEditableNodes == CollectNonEditableNodes::No) { + for (size_t i : Reversed(IntegerRange(aOutArrayOfContents.Length()))) { + if (!EditorUtils::IsEditableContent(aOutArrayOfContents[i], + EditorUtils::EditorType::HTML)) { + aOutArrayOfContents.RemoveElementAt(i); + } + } + } + } + + switch (aEditSubAction) { + case EditSubAction::eCreateOrRemoveBlock: { + // Certain operations should not act on li's and td's, but rather inside + // them. Alter the list as needed. + CollectChildrenOptions options = { + CollectChildrenOption::CollectListChildren, + CollectChildrenOption::CollectTableChildren}; + if (aCollectNonEditableNodes == CollectNonEditableNodes::No) { + options += CollectChildrenOption::IgnoreNonEditableChildren; + } + for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) { + OwningNonNull content = aOutArrayOfContents[i]; + if (HTMLEditUtils::IsListItem(content)) { + aOutArrayOfContents.RemoveElementAt(i); + HTMLEditUtils::CollectChildren(*content, aOutArrayOfContents, i, + options); + } + } + // Empty text node shouldn't be selected if unnecessary + for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) { + if (Text* text = aOutArrayOfContents[i]->GetAsText()) { + // Don't select empty text except to empty block + if (!HTMLEditUtils::IsVisibleTextNode(*text)) { + aOutArrayOfContents.RemoveElementAt(i); + } + } + } + break; + } + case EditSubAction::eCreateOrChangeList: { + // XXX aCollectNonEditableNodes is ignored here. Maybe a bug. + CollectChildrenOptions options = { + CollectChildrenOption::CollectTableChildren}; + for (size_t i = aOutArrayOfContents.Length(); i > 0; i--) { + // Scan for table elements. If we find table elements other than + // table, replace it with a list of any editable non-table content + // because if a selection range starts from end in a table-cell and + // ends at or starts from outside the ``, we need to make + // lists in each selected table-cells. + OwningNonNull content = aOutArrayOfContents[i - 1]; + if (HTMLEditUtils::IsAnyTableElementButNotTable(content)) { + aOutArrayOfContents.RemoveElementAt(i - 1); + HTMLEditUtils::CollectChildren(content, aOutArrayOfContents, i - 1, + options); + } + } + // If there is only one node in the array, and it is a `

`, + // `

` or a list element, then look inside of it until we + // find inner list or content. + if (aOutArrayOfContents.Length() != 1) { + break; + } + Element* deepestDivBlockquoteOrListElement = + HTMLEditUtils::GetInclusiveDeepestFirstChildWhichHasOneChild( + aOutArrayOfContents[0], + {HTMLEditUtils::WalkTreeOption::IgnoreNonEditableNode}, + nsGkAtoms::div, nsGkAtoms::blockquote, nsGkAtoms::ul, + nsGkAtoms::ol, nsGkAtoms::dl); + if (!deepestDivBlockquoteOrListElement) { + break; + } + if (deepestDivBlockquoteOrListElement->IsAnyOfHTMLElements( + nsGkAtoms::div, nsGkAtoms::blockquote)) { + aOutArrayOfContents.Clear(); + // XXX Before we're called, non-editable nodes are ignored. However, + // we may append non-editable nodes here. + HTMLEditUtils::CollectChildren(*deepestDivBlockquoteOrListElement, + aOutArrayOfContents, 0, {}); + break; + } + aOutArrayOfContents.ReplaceElementAt( + 0, OwningNonNull(*deepestDivBlockquoteOrListElement)); + break; + } + case EditSubAction::eOutdent: + case EditSubAction::eIndent: + case EditSubAction::eSetPositionToAbsolute: { + // Indent/outdent already do something special for list items, but we + // still need to make sure we don't act on table elements + CollectChildrenOptions options = { + CollectChildrenOption::CollectListChildren, + CollectChildrenOption::CollectTableChildren}; + if (aCollectNonEditableNodes == CollectNonEditableNodes::No) { + options += CollectChildrenOption::IgnoreNonEditableChildren; + } + for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) { + OwningNonNull content = aOutArrayOfContents[i]; + if (HTMLEditUtils::IsAnyTableElementButNotTable(content)) { + aOutArrayOfContents.RemoveElementAt(i); + HTMLEditUtils::CollectChildren(*content, aOutArrayOfContents, i, + options); + } + } + break; + } + default: + break; + } + + // Outdent should look inside of divs. + if (aEditSubAction == EditSubAction::eOutdent && + !aHTMLEditor.IsCSSEnabled()) { + CollectChildrenOptions options = {}; + if (aCollectNonEditableNodes == CollectNonEditableNodes::No) { + options += CollectChildrenOption::IgnoreNonEditableChildren; + } + for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) { + OwningNonNull content = aOutArrayOfContents[i]; + if (content->IsHTMLElement(nsGkAtoms::div)) { + aOutArrayOfContents.RemoveElementAt(i); + HTMLEditUtils::CollectChildren(*content, aOutArrayOfContents, i, + options); + } + } + } + + return NS_OK; +} + +Element* AutoRangeArray::GetClosestAncestorAnyListElementOfRange() const { + for (const OwningNonNull& range : mRanges) { + nsINode* commonAncestorNode = range->GetClosestCommonInclusiveAncestor(); + if (MOZ_UNLIKELY(!commonAncestorNode)) { + continue; + } + for (Element* element : + commonAncestorNode->InclusiveAncestorsOfType()) { + if (HTMLEditUtils::IsAnyListElement(element)) { + return element; + } + } + } + return nullptr; +} + +} // namespace mozilla -- cgit v1.2.3