element, we should // insert a
element. else if (editingHost == blockElement) { insertBRElement = separator == ParagraphSeparator::br || !HTMLEditUtils::CanElementContainParagraph(*editingHost); } // If the nearest block parent is a single-line container declared in // the execCommand spec and not the editing host, we should separate the // block even if the default paragraph separator is
element. else if (HTMLEditUtils::IsSingleLineContainer(*blockElement)) { insertBRElement = false; } // Otherwise, unless there is no block ancestor which can contain

// element, we shouldn't insert a
element here. else { insertBRElement = true; for (Element* blockAncestor = blockElement; blockAncestor && insertBRElement; blockAncestor = HTMLEditUtils::GetAncestorBlockElement(*blockAncestor, editingHost)) { insertBRElement = !HTMLEditUtils::CanElementContainParagraph(*blockAncestor); } } // If we cannot insert a

element at the selection, we should insert // a
element instead. if (insertBRElement) { nsresult rv = InsertBRElement(atStartOfSelection); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::InsertBRElement() failed"); return EditActionIgnored(rv); } return EditActionHandled(); } if (editingHost == blockElement && separator != ParagraphSeparator::br) { // Insert a new block first MOZ_ASSERT(separator == ParagraphSeparator::div || separator == ParagraphSeparator::p); // FormatBlockContainerWithTransaction() creates AutoSelectionRestorer. // Therefore, even if it returns NS_OK, editor might have been destroyed // at restoring Selection. nsresult rv = FormatBlockContainerWithTransaction( MOZ_KnownLive(HTMLEditor::ToParagraphSeparatorTagName(separator))); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED) || NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } // We warn on failure, but don't handle it, because it might be harmless. // Instead we just check that a new block was actually created. NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::FormatBlockContainerWithTransaction() " "failed, but ignored"); firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return EditActionIgnored(NS_ERROR_FAILURE); } atStartOfSelection = firstRange->StartRef(); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return EditActionIgnored(NS_ERROR_FAILURE); } MOZ_ASSERT(atStartOfSelection.IsSetAndValid()); blockElement = atStartOfSelection.IsInContentNode() ? HTMLEditUtils::GetInclusiveAncestorBlockElement( *atStartOfSelection.ContainerAsContent(), editingHost) : nullptr; if (NS_WARN_IF(!blockElement)) { return EditActionIgnored(NS_ERROR_UNEXPECTED); } if (NS_WARN_IF(blockElement == editingHost)) { // Didn't create a new block for some reason, fall back to
rv = InsertBRElement(atStartOfSelection); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::InsertBRElement() failed"); return EditActionIgnored(rv); } return EditActionHandled(); } // Now, mNewBlockElement is last created block element for wrapping inline // elements around the caret position and AfterEditInner() will move // caret into it. However, it may be different from block parent of // the caret position. E.g., FormatBlockContainerWithTransaction() may // wrap following inline elements of a
element which is next sibling // of container of the caret. So, we need to adjust mNewBlockElement here // for avoiding jumping caret to odd position. TopLevelEditSubActionDataRef().mNewBlockElement = blockElement; } // If block is empty, populate with br. (For example, imagine a div that // contains the word "text". The user selects "text" and types return. // "Text" is deleted leaving an empty block. We want to put in one br to // make block have a line. Then code further below will put in a second br.) if (IsEmptyBlockElement(*blockElement, IgnoreSingleBR::No)) { AutoEditorDOMPointChildInvalidator lockOffset(atStartOfSelection); EditorDOMPoint endOfBlockParent; endOfBlockParent.SetToEndOf(blockElement); RefPtr brElement = InsertBRElementWithTransaction(endOfBlockParent); if (NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } if (!brElement) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return EditActionIgnored(NS_ERROR_FAILURE); } } RefPtr listItem = GetNearestAncestorListItemElement(*blockElement); if (listItem && listItem != editingHost) { nsresult rv = HandleInsertParagraphInListItemElement( *listItem, MOZ_KnownLive(*atStartOfSelection.GetContainer()), atStartOfSelection.Offset()); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::HandleInsertParagraphInListItemElement() " "failed, but ignored"); return EditActionHandled(); } if (HTMLEditUtils::IsHeader(*blockElement)) { // Headers: close (or split) header nsresult rv = HandleInsertParagraphInHeadingElement( *blockElement, MOZ_KnownLive(*atStartOfSelection.GetContainer()), atStartOfSelection.Offset()); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::HandleInsertParagraphInHeadingElement() " "failed, but ignored"); return EditActionHandled(); } // XXX Ideally, we should take same behavior with both

container and //

container. However, we are still using
as default // paragraph separator (non-standard) and we've split only

container // long time. Therefore, some web apps may depend on this behavior like // Gmail. So, let's use traditional odd behavior only when the default // paragraph separator is
. Otherwise, take consistent behavior // between

container and

container. if ((separator == ParagraphSeparator::br && blockElement->IsHTMLElement(nsGkAtoms::p)) || (separator != ParagraphSeparator::br && blockElement->IsAnyOfHTMLElements(nsGkAtoms::p, nsGkAtoms::div))) { AutoEditorDOMPointChildInvalidator lockOffset(atStartOfSelection); // Paragraphs: special rules to look for
s EditActionResult result = HandleInsertParagraphInParagraph(*blockElement); if (result.Failed()) { NS_WARNING("HTMLEditor::HandleInsertParagraphInParagraph() failed"); return result; } if (result.Handled()) { // Now, atStartOfSelection may be invalid because the left paragraph // may have less children than its offset. For avoiding warnings of // validation of EditorDOMPoint, we should not touch it anymore. lockOffset.Cancel(); return result; } // Fall through, if HandleInsertParagraphInParagraph() didn't handle it. MOZ_ASSERT(!result.Canceled(), "HandleInsertParagraphInParagraph() canceled this edit action, " "InsertParagraphSeparatorAsSubAction() needs to handle this " "action instead"); } // If nobody handles this edit action, let's insert new
at the selection. rv = InsertBRElement(atStartOfSelection); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::InsertBRElement() failed"); return EditActionIgnored(rv); } return EditActionHandled(); } nsresult HTMLEditor::InsertBRElement(const EditorDOMPoint& aPointToBreak) { MOZ_ASSERT(IsEditActionDataAvailable()); if (NS_WARN_IF(!aPointToBreak.IsSet())) { return NS_ERROR_INVALID_ARG; } bool brElementIsAfterBlock = false, brElementIsBeforeBlock = false; // First, insert a
element. RefPtr brElement; if (IsPlaintextEditor()) { brElement = InsertBRElementWithTransaction(aPointToBreak); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!brElement) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return NS_ERROR_FAILURE; } } else { EditorDOMPoint pointToBreak(aPointToBreak); WSRunScanner wsRunScanner(*this, pointToBreak); WSScanResult backwardScanResult = wsRunScanner.ScanPreviousVisibleNodeOrBlockBoundaryFrom(pointToBreak); if (backwardScanResult.Failed()) { NS_WARNING( "WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundaryFrom() failed"); return NS_ERROR_FAILURE; } brElementIsAfterBlock = backwardScanResult.ReachedBlockBoundary(); WSScanResult forwardScanResult = wsRunScanner.ScanNextVisibleNodeOrBlockBoundaryFrom(pointToBreak); if (forwardScanResult.Failed()) { NS_WARNING( "WSRunScanner::ScanNextVisibleNodeOrBlockBoundaryFrom() failed"); return NS_ERROR_FAILURE; } brElementIsBeforeBlock = forwardScanResult.ReachedBlockBoundary(); // If the container of the break is a link, we need to split it and // insert new
between the split links. RefPtr linkNode = HTMLEditor::GetLinkElement(pointToBreak.GetContainer()); if (linkNode) { SplitNodeResult splitLinkNodeResult = SplitNodeDeepWithTransaction( *linkNode, pointToBreak, SplitAtEdges::eDoNotCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (splitLinkNodeResult.Failed()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) failed"); return splitLinkNodeResult.Rv(); } pointToBreak = splitLinkNodeResult.SplitPoint(); } Result, nsresult> result = WhiteSpaceVisibilityKeeper::InsertBRElement(*this, pointToBreak); if (result.isErr()) { NS_WARNING("WhiteSpaceVisibilityKeeper::InsertBRElement() failed"); return result.inspectErr(); } brElement = result.unwrap(); MOZ_ASSERT(brElement); } // If the
element has already been removed from the DOM tree by a // mutation event listener, don't continue handling this. if (NS_WARN_IF(!brElement->GetParentNode())) { return NS_ERROR_FAILURE; } if (brElementIsAfterBlock && brElementIsBeforeBlock) { // We just placed a
between block boundaries. This is the one case // where we want the selection to be before the br we just placed, as the // br will be on a new line, rather than at end of prior line. // XXX brElementIsAfterBlock and brElementIsBeforeBlock were set before // modifying the DOM tree. So, now, the
element may not be // between blocks. IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition(true, ignoredError); NS_WARNING_ASSERTION( !ignoredError.Failed(), "Selection::SetInterlinePosition(true) failed, but ignored"); nsresult rv = CollapseSelectionTo(EditorRawDOMPoint(brElement)); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } EditorDOMPoint afterBRElement(brElement); DebugOnly advanced = afterBRElement.AdvanceOffset(); NS_WARNING_ASSERTION(advanced, "Failed to advance offset after the new
element"); WSScanResult forwardScanFromAfterBRElementResult = WSRunScanner::ScanNextVisibleNodeOrBlockBoundary(*this, afterBRElement); if (forwardScanFromAfterBRElementResult.Failed()) { NS_WARNING("WSRunScanner::ScanNextVisibleNodeOrBlockBoundary() failed"); return NS_ERROR_FAILURE; } if (forwardScanFromAfterBRElementResult.ReachedBRElement()) { // The next thing after the break we inserted is another break. Move the // second break to be the first break's sibling. This will prevent them // from being in different inline nodes, which would break // SetInterlinePosition(). It will also assure that if the user clicks // away and then clicks back on their new blank line, they will still get // the style from the line above. if (brElement->GetNextSibling() != forwardScanFromAfterBRElementResult.BRElementPtr()) { MOZ_ASSERT(forwardScanFromAfterBRElementResult.BRElementPtr()); nsresult rv = MoveNodeWithTransaction( MOZ_KnownLive(*forwardScanFromAfterBRElementResult.BRElementPtr()), afterBRElement); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); return rv; } } } // SetInterlinePosition(true) means we want the caret to stick to the // content on the "right". We want the caret to stick to whatever is past // the break. This is because the break is on the same line we were on, // but the next content will be on the following line. // An exception to this is if the break has a next sibling that is a block // node. Then we stick to the left to avoid an uber caret. nsIContent* nextSiblingOfBRElement = brElement->GetNextSibling(); IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition( !(nextSiblingOfBRElement && HTMLEditUtils::IsBlockElement(*nextSiblingOfBRElement)), ignoredError); NS_WARNING_ASSERTION(!ignoredError.Failed(), "Selection::SetInterlinePosition() failed, but ignored"); nsresult rv = CollapseSelectionTo(afterBRElement); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } EditActionResult HTMLEditor::SplitMailCiteElements( const EditorDOMPoint& aPointToSplit) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aPointToSplit.IsSet()); RefPtr citeNode = GetMostAncestorMailCiteElement(*aPointToSplit.GetContainer()); if (!citeNode) { return EditActionIgnored(); } EditorDOMPoint pointToSplit(aPointToSplit); // If our selection is just before a break, nudge it to be just after it. // This does two things for us. It saves us the trouble of having to add // a break here ourselves to preserve the "blockness" of the inline span // mailquote (in the inline case), and : // it means the break won't end up making an empty line that happens to be // inside a mailquote (in either inline or block case). // The latter can confuse a user if they click there and start typing, // because being in the mailquote may affect wrapping behavior, or font // color, etc. WSScanResult forwardScanFromPointToSplitResult = WSRunScanner::ScanNextVisibleNodeOrBlockBoundary(*this, pointToSplit); if (forwardScanFromPointToSplitResult.Failed()) { return EditActionResult(NS_ERROR_FAILURE); } // If selection start point is before a break and it's inside the mailquote, // let's split it after the visible node. if (forwardScanFromPointToSplitResult.ReachedBRElement() && forwardScanFromPointToSplitResult.BRElementPtr() != citeNode && citeNode->Contains(forwardScanFromPointToSplitResult.BRElementPtr())) { pointToSplit = forwardScanFromPointToSplitResult.PointAfterContent(); } if (NS_WARN_IF(!pointToSplit.GetContainerAsContent())) { return EditActionIgnored(NS_ERROR_FAILURE); } SplitNodeResult splitCiteNodeResult = SplitNodeDeepWithTransaction( *citeNode, pointToSplit, SplitAtEdges::eDoNotCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } if (splitCiteNodeResult.Failed()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) failed"); return EditActionIgnored(splitCiteNodeResult.Rv()); } pointToSplit.Clear(); // Add an invisible
to the end of current cite node (If new left cite // has not been created, we're at the end of it. Otherwise, we're still at // the right node) if it was a of style="display: block". This is // important, since when serializing the cite to plain text, the span which // caused the visual break is discarded. So the added
will guarantee // that the serializer will insert a break where the user saw one. // FYI: splitCiteNodeResult grabs the previous node with nsCOMPtr. So, it's // safe to access previousNodeOfSplitPoint even after changing the DOM // tree and/or selection even though it's raw pointer. nsIContent* previousNodeOfSplitPoint = splitCiteNodeResult.GetPreviousNode(); if (previousNodeOfSplitPoint && previousNodeOfSplitPoint->IsHTMLElement(nsGkAtoms::span) && previousNodeOfSplitPoint->GetPrimaryFrame() && previousNodeOfSplitPoint->GetPrimaryFrame()->IsBlockFrameOrSubclass()) { nsCOMPtr lastChild = previousNodeOfSplitPoint->GetLastChild(); if (lastChild && !lastChild->IsHTMLElement(nsGkAtoms::br)) { // We ignore the result here. EditorDOMPoint endOfPreviousNodeOfSplitPoint; endOfPreviousNodeOfSplitPoint.SetToEndOf(previousNodeOfSplitPoint); RefPtr invisibleBRElement = InsertBRElementWithTransaction(endOfPreviousNodeOfSplitPoint); if (NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( invisibleBRElement, "HTMLEditor::InsertBRElementWithTransaction() failed, but ignored"); } } // In most cases,
should be inserted after current cite. However, if // left cite hasn't been created because the split point was start of the // cite node,
should be inserted before the current cite. EditorDOMPoint pointToInsertBRNode(splitCiteNodeResult.SplitPoint()); RefPtr brElement = InsertBRElementWithTransaction(pointToInsertBRNode); if (NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } if (!brElement) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return EditActionIgnored(NS_ERROR_FAILURE); } // Now, offset of pointToInsertBRNode is invalid. Let's clear it. pointToInsertBRNode.Clear(); // Want selection before the break, and on same line. EditorDOMPoint atBRElement(brElement); { AutoEditorDOMPointChildInvalidator lockOffset(atBRElement); IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition(true, ignoredError); NS_WARNING_ASSERTION( !ignoredError.Failed(), "Selection::SetInterlinePosition(true) failed, but ignored"); nsresult rv = CollapseSelectionTo(atBRElement); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::CollapseSelectionTo() failed"); return EditActionIgnored(rv); } } // if citeNode wasn't a block, we might also want another break before it. // We need to examine the content both before the br we just added and also // just after it. If we don't have another br or block boundary adjacent, // then we will need a 2nd br added to achieve blank line that user expects. if (HTMLEditUtils::IsInlineElement(*citeNode)) { // Use DOM point which we tried to collapse to. EditorDOMPoint pointToCreateNewBRElement(atBRElement); WSScanResult backwardScanFromPointToCreateNewBRElementResult = WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundary( *this, pointToCreateNewBRElement); if (backwardScanFromPointToCreateNewBRElementResult.Failed()) { NS_WARNING( "WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundary() failed"); return EditActionResult(NS_ERROR_FAILURE); } if (backwardScanFromPointToCreateNewBRElementResult .InNormalWhiteSpacesOrText() || backwardScanFromPointToCreateNewBRElementResult .ReachedSpecialContent()) { EditorRawDOMPoint pointAfterNewBRElement( EditorRawDOMPoint::After(pointToCreateNewBRElement)); NS_WARNING_ASSERTION(pointAfterNewBRElement.IsSet(), "Failed to set to after the
node"); WSScanResult forwardScanFromPointAfterNewBRElementResult = WSRunScanner::ScanNextVisibleNodeOrBlockBoundary( *this, pointAfterNewBRElement); if (forwardScanFromPointAfterNewBRElementResult.Failed()) { NS_WARNING("WSRunScanner::ScanNextVisibleNodeOrBlockBoundary() failed"); return EditActionResult(NS_ERROR_FAILURE); } if (forwardScanFromPointAfterNewBRElementResult .InNormalWhiteSpacesOrText() || forwardScanFromPointAfterNewBRElementResult.ReachedSpecialContent() || // In case we're at the very end. forwardScanFromPointAfterNewBRElementResult .ReachedCurrentBlockBoundary()) { brElement = InsertBRElementWithTransaction(pointToCreateNewBRElement); if (NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } if (!brElement) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return EditActionIgnored(NS_ERROR_FAILURE); } // Now, those points may be invalid. pointToCreateNewBRElement.Clear(); pointAfterNewBRElement.Clear(); } } } // delete any empty cites if (previousNodeOfSplitPoint && IsEmptyNode(*previousNodeOfSplitPoint, true, false)) { nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*previousNodeOfSplitPoint)); if (NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return EditActionIgnored(rv); } } if (citeNode && IsEmptyNode(*citeNode, true, false)) { nsresult rv = DeleteNodeWithTransaction(*citeNode); if (NS_WARN_IF(Destroyed())) { return EditActionIgnored(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return EditActionIgnored(rv); } } return EditActionHandled(); } HTMLEditor::CharPointData HTMLEditor::GetPreviousCharPointDataForNormalizingWhiteSpaces( const EditorDOMPointInText& aPoint) const { MOZ_ASSERT(aPoint.IsSetAndValid()); if (!aPoint.IsStartOfContainer()) { return CharPointData::InSameTextNode( HTMLEditor::GetPreviousCharPointType(aPoint)); } EditorDOMPointInText previousCharPoint = WSRunScanner::GetPreviousEditableCharPoint(*this, aPoint); if (!previousCharPoint.IsSet()) { return CharPointData::InDifferentTextNode(CharPointType::TextEnd); } return CharPointData::InDifferentTextNode( HTMLEditor::GetCharPointType(previousCharPoint)); } HTMLEditor::CharPointData HTMLEditor::GetInclusiveNextCharPointDataForNormalizingWhiteSpaces( const EditorDOMPointInText& aPoint) const { MOZ_ASSERT(aPoint.IsSetAndValid()); if (!aPoint.IsEndOfContainer()) { return CharPointData::InSameTextNode(HTMLEditor::GetCharPointType(aPoint)); } EditorDOMPointInText nextCharPoint = WSRunScanner::GetInclusiveNextEditableCharPoint(*this, aPoint); if (!nextCharPoint.IsSet()) { return CharPointData::InDifferentTextNode(CharPointType::TextEnd); } return CharPointData::InDifferentTextNode( HTMLEditor::GetCharPointType(nextCharPoint)); } // static void HTMLEditor::GenerateWhiteSpaceSequence( nsAString& aResult, uint32_t aLength, const CharPointData& aPreviousCharPointData, const CharPointData& aNextCharPointData) { MOZ_ASSERT(aResult.IsEmpty()); MOZ_ASSERT(aLength); // For now, this method does not assume that result will be append to // white-space sequence in the text node. MOZ_ASSERT(aPreviousCharPointData.AcrossTextNodeBoundary() || !aPreviousCharPointData.IsWhiteSpace()); // For now, this method does not assume that the result will be inserted // into white-space sequence nor start of white-space sequence. MOZ_ASSERT(aNextCharPointData.AcrossTextNodeBoundary() || !aNextCharPointData.IsWhiteSpace()); if (aLength == 1) { // Even if previous/next char is in different text node, we should put // an ASCII white-space between visible characters. // XXX This means that this does not allow to put an NBSP in HTML editor // without preformatted style. However, Chrome has same issue too. if (aPreviousCharPointData.Type() == CharPointType::VisibleChar && aNextCharPointData.Type() == CharPointType::VisibleChar) { aResult.Assign(HTMLEditUtils::kSpace); return; } // If it's start or end of text, put an NBSP. if (aPreviousCharPointData.Type() == CharPointType::TextEnd || aNextCharPointData.Type() == CharPointType::TextEnd) { aResult.Assign(HTMLEditUtils::kNBSP); return; } // Now, the white-space will be inserted to a white-space sequence, but not // end of text. We can put an ASCII white-space only when both sides are // not ASCII white-spaces. aResult.Assign( aPreviousCharPointData.Type() == CharPointType::ASCIIWhiteSpace || aNextCharPointData.Type() == CharPointType::ASCIIWhiteSpace ? HTMLEditUtils::kNBSP : HTMLEditUtils::kSpace); return; } // Generate pairs of NBSP and ASCII white-space. aResult.SetLength(aLength); bool appendNBSP = true; // Basically, starts with an NBSP. char16_t* lastChar = aResult.EndWriting() - 1; for (char16_t* iter = aResult.BeginWriting(); iter != lastChar; iter++) { *iter = appendNBSP ? HTMLEditUtils::kNBSP : HTMLEditUtils::kSpace; appendNBSP = !appendNBSP; } // If the final one is expected to an NBSP, we can put an NBSP simply. if (appendNBSP) { *lastChar = HTMLEditUtils::kNBSP; return; } // If next char point is end of text node or an ASCII white-space, we need to // put an NBSP. *lastChar = aNextCharPointData.AcrossTextNodeBoundary() || aNextCharPointData.Type() == CharPointType::ASCIIWhiteSpace ? HTMLEditUtils::kNBSP : HTMLEditUtils::kSpace; } void HTMLEditor::ExtendRangeToDeleteWithNormalizingWhiteSpaces( EditorDOMPointInText& aStartToDelete, EditorDOMPointInText& aEndToDelete, nsAString& aNormalizedWhiteSpacesInStartNode, nsAString& aNormalizedWhiteSpacesInEndNode) const { MOZ_ASSERT(aStartToDelete.IsSetAndValid()); MOZ_ASSERT(aEndToDelete.IsSetAndValid()); MOZ_ASSERT(aStartToDelete.EqualsOrIsBefore(aEndToDelete)); MOZ_ASSERT(aNormalizedWhiteSpacesInStartNode.IsEmpty()); MOZ_ASSERT(aNormalizedWhiteSpacesInEndNode.IsEmpty()); // First, check whether there is surrounding white-spaces or not, and if there // are, check whether they are collapsible or not. Note that we shouldn't // touch white-spaces in different text nodes for performance, but we need // adjacent text node's first or last character information in some cases. EditorDOMPointInText precedingCharPoint = WSRunScanner::GetPreviousEditableCharPoint(*this, aStartToDelete); EditorDOMPointInText followingCharPoint = WSRunScanner::GetInclusiveNextEditableCharPoint(*this, aEndToDelete); // Blink-compat: Normalize white-spaces in first node only when not removing // its last character or no text nodes follow the first node. // If removing last character of first node and there are // following text nodes, white-spaces in following text node are // normalized instead. const bool removingLastCharOfStartNode = aStartToDelete.ContainerAsText() != aEndToDelete.ContainerAsText() || (aEndToDelete.IsEndOfContainer() && followingCharPoint.IsSet()); const bool maybeNormalizePrecedingWhiteSpaces = !removingLastCharOfStartNode && precedingCharPoint.IsSet() && !precedingCharPoint.IsEndOfContainer() && precedingCharPoint.ContainerAsText() == aStartToDelete.ContainerAsText() && precedingCharPoint.IsCharASCIISpaceOrNBSP() && !EditorUtils::IsContentPreformatted( *precedingCharPoint.ContainerAsText()); const bool maybeNormalizeFollowingWhiteSpaces = followingCharPoint.IsSet() && !followingCharPoint.IsEndOfContainer() && (followingCharPoint.ContainerAsText() == aEndToDelete.ContainerAsText() || removingLastCharOfStartNode) && followingCharPoint.IsCharASCIISpaceOrNBSP() && !EditorUtils::IsContentPreformatted( *followingCharPoint.ContainerAsText()); if (!maybeNormalizePrecedingWhiteSpaces && !maybeNormalizeFollowingWhiteSpaces) { return; // There are no white-spaces. } // Next, consider the range to normalize. EditorDOMPointInText startToNormalize, endToNormalize; if (maybeNormalizePrecedingWhiteSpaces) { Maybe previousCharOffsetOfWhiteSpaces = HTMLEditUtils::GetPreviousCharOffsetExceptWhiteSpaces( precedingCharPoint); startToNormalize.Set(precedingCharPoint.ContainerAsText(), previousCharOffsetOfWhiteSpaces.isSome() ? previousCharOffsetOfWhiteSpaces.value() + 1 : 0); MOZ_ASSERT(!startToNormalize.IsEndOfContainer()); } if (maybeNormalizeFollowingWhiteSpaces) { Maybe nextCharOffsetOfWhiteSpaces = HTMLEditUtils::GetInclusiveNextCharOffsetExceptWhiteSpaces( followingCharPoint); if (nextCharOffsetOfWhiteSpaces.isSome()) { endToNormalize.Set(followingCharPoint.ContainerAsText(), nextCharOffsetOfWhiteSpaces.value()); } else { endToNormalize.SetToEndOf(followingCharPoint.ContainerAsText()); } MOZ_ASSERT(!endToNormalize.IsStartOfContainer()); } // Next, retrieve surrounding information of white-space sequence. // If we're removing first text node's last character, we need to // normalize white-spaces starts from another text node. In this case, // we need to lie for avoiding assertion in GenerateWhiteSpaceSequence(). CharPointData previousCharPointData = removingLastCharOfStartNode ? CharPointData::InDifferentTextNode(CharPointType::TextEnd) : GetPreviousCharPointDataForNormalizingWhiteSpaces( startToNormalize.IsSet() ? startToNormalize : aStartToDelete); CharPointData nextCharPointData = GetInclusiveNextCharPointDataForNormalizingWhiteSpaces( endToNormalize.IsSet() ? endToNormalize : aEndToDelete); // Next, compute number of white-spaces in start/end node. uint32_t lengthInStartNode = 0, lengthInEndNode = 0; if (startToNormalize.IsSet()) { MOZ_ASSERT(startToNormalize.ContainerAsText() == aStartToDelete.ContainerAsText()); lengthInStartNode = aStartToDelete.Offset() - startToNormalize.Offset(); MOZ_ASSERT(lengthInStartNode); } if (endToNormalize.IsSet()) { lengthInEndNode = endToNormalize.ContainerAsText() == aEndToDelete.ContainerAsText() ? endToNormalize.Offset() - aEndToDelete.Offset() : endToNormalize.Offset(); MOZ_ASSERT(lengthInEndNode); // If we normalize white-spaces in a text node, we can replace all of them // with one ReplaceTextTransaction. if (endToNormalize.ContainerAsText() == aStartToDelete.ContainerAsText()) { lengthInStartNode += lengthInEndNode; lengthInEndNode = 0; } } MOZ_ASSERT(lengthInStartNode + lengthInEndNode); // Next, generate normalized white-spaces. if (!lengthInEndNode) { HTMLEditor::GenerateWhiteSpaceSequence( aNormalizedWhiteSpacesInStartNode, lengthInStartNode, previousCharPointData, nextCharPointData); } else if (!lengthInStartNode) { HTMLEditor::GenerateWhiteSpaceSequence( aNormalizedWhiteSpacesInEndNode, lengthInEndNode, previousCharPointData, nextCharPointData); } else { // For making `GenerateWhiteSpaceSequence()` simpler, we should create // whole white-space sequence first, then, copy to the out params. nsAutoString whiteSpaces; HTMLEditor::GenerateWhiteSpaceSequence( whiteSpaces, lengthInStartNode + lengthInEndNode, previousCharPointData, nextCharPointData); aNormalizedWhiteSpacesInStartNode = Substring(whiteSpaces, 0, lengthInStartNode); aNormalizedWhiteSpacesInEndNode = Substring(whiteSpaces, lengthInStartNode); MOZ_ASSERT(aNormalizedWhiteSpacesInEndNode.Length() == lengthInEndNode); } // TODO: Shrink the replacing range and string as far as possible because // this may run a lot, i.e., HTMLEditor creates ReplaceTextTransaction // a lot for normalizing white-spaces. Then, each transaction shouldn't // have all white-spaces every time because once it's normalized, we // don't need to normalize all of the sequence again, but currently // we do. // Finally, extend the range. if (startToNormalize.IsSet()) { aStartToDelete = startToNormalize; } if (endToNormalize.IsSet()) { aEndToDelete = endToNormalize; } } Result HTMLEditor::DeleteTextAndNormalizeSurroundingWhiteSpaces( const EditorDOMPointInText& aStartToDelete, const EditorDOMPointInText& aEndToDelete, TreatEmptyTextNodes aTreatEmptyTextNodes, DeleteDirection aDeleteDirection) { MOZ_ASSERT(aStartToDelete.IsSetAndValid()); MOZ_ASSERT(aEndToDelete.IsSetAndValid()); MOZ_ASSERT(aStartToDelete.EqualsOrIsBefore(aEndToDelete)); // Use nsString for these replacing string because we should avoid to copy // the buffer from auto storange to ReplaceTextTransaction. nsString normalizedWhiteSpacesInFirstNode, normalizedWhiteSpacesInLastNode; // First, check whether we need to normalize white-spaces after deleting // the given range. EditorDOMPointInText startToDelete(aStartToDelete); EditorDOMPointInText endToDelete(aEndToDelete); ExtendRangeToDeleteWithNormalizingWhiteSpaces( startToDelete, endToDelete, normalizedWhiteSpacesInFirstNode, normalizedWhiteSpacesInLastNode); // If extended range is still collapsed, i.e., the caller just wants to // normalize white-space sequence, but there is no white-spaces which need to // be replaced, we need to do nothing here. if (startToDelete == endToDelete) { return EditorDOMPoint(aStartToDelete); } // Note that the container text node of startToDelete may be removed from // the tree if it becomes empty. Therefore, we need to track the point. EditorDOMPoint newCaretPosition; if (aStartToDelete.ContainerAsText() == aEndToDelete.ContainerAsText()) { newCaretPosition = aEndToDelete; } else if (aDeleteDirection == DeleteDirection::Forward) { newCaretPosition.SetToEndOf(aStartToDelete.ContainerAsText()); } else { newCaretPosition.Set(aEndToDelete.ContainerAsText(), 0); } // Then, modify the text nodes in the range. while (true) { AutoTrackDOMPoint trackingNewCaretPosition(RangeUpdaterRef(), &newCaretPosition); // Use ReplaceTextTransaction if we need to normalize white-spaces in // the first text node. if (!normalizedWhiteSpacesInFirstNode.IsEmpty()) { EditorDOMPoint trackingEndToDelete(endToDelete.ContainerAsText(), endToDelete.Offset()); { AutoTrackDOMPoint trackEndToDelete(RangeUpdaterRef(), &trackingEndToDelete); uint32_t lengthToReplaceInFirstTextNode = startToDelete.ContainerAsText() == trackingEndToDelete.ContainerAsText() ? trackingEndToDelete.Offset() - startToDelete.Offset() : startToDelete.ContainerAsText()->TextLength() - startToDelete.Offset(); nsresult rv = ReplaceTextWithTransaction( MOZ_KnownLive(*startToDelete.ContainerAsText()), startToDelete.Offset(), lengthToReplaceInFirstTextNode, normalizedWhiteSpacesInFirstNode); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::ReplaceTextWithTransaction() failed"); return Err(rv); } if (startToDelete.ContainerAsText() == trackingEndToDelete.ContainerAsText()) { MOZ_ASSERT(normalizedWhiteSpacesInLastNode.IsEmpty()); break; // There is no more text which we need to delete. } } if (MayHaveMutationEventListeners( NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED) && (NS_WARN_IF(!trackingEndToDelete.IsSetAndValid()) || NS_WARN_IF(!trackingEndToDelete.IsInTextNode()))) { return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } MOZ_ASSERT(trackingEndToDelete.IsInTextNode()); endToDelete.Set(trackingEndToDelete.ContainerAsText(), trackingEndToDelete.Offset()); // If the remaining range was modified by mutation event listener, // we should stop handling the deletion. startToDelete = EditorDOMPointInText::AtEndOf(*startToDelete.ContainerAsText()); if (MayHaveMutationEventListeners( NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED) && NS_WARN_IF(!startToDelete.IsBefore(endToDelete))) { return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } } // Delete ASCII whiteSpaces in the range simpley if there are some text // nodes which we don't need to replace their text. if (normalizedWhiteSpacesInLastNode.IsEmpty() || startToDelete.ContainerAsText() != endToDelete.ContainerAsText()) { // If we need to replace text in the last text node, we should // delete text before its previous text node. EditorDOMPointInText endToDeleteExceptReplaceRange = normalizedWhiteSpacesInLastNode.IsEmpty() ? endToDelete : EditorDOMPointInText(endToDelete.ContainerAsText(), 0); if (startToDelete != endToDeleteExceptReplaceRange) { nsresult rv = DeleteTextAndTextNodesWithTransaction( startToDelete, endToDeleteExceptReplaceRange, aTreatEmptyTextNodes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::DeleteTextAndTextNodesWithTransaction() failed"); return Err(rv); } if (normalizedWhiteSpacesInLastNode.IsEmpty()) { break; // There is no more text which we need to delete. } if (MayHaveMutationEventListeners( NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED | NS_EVENT_BITS_MUTATION_NODEREMOVED | NS_EVENT_BITS_MUTATION_NODEREMOVEDFROMDOCUMENT | NS_EVENT_BITS_MUTATION_SUBTREEMODIFIED) && (NS_WARN_IF(!endToDeleteExceptReplaceRange.IsSetAndValid()) || NS_WARN_IF(!endToDelete.IsSetAndValid()) || NS_WARN_IF(endToDelete.IsStartOfContainer()))) { return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } // Then, replace the text in the last text node. startToDelete = endToDeleteExceptReplaceRange; } } // Replace ASCII whiteSpaces in the range and following character in the // last text node. MOZ_ASSERT(!normalizedWhiteSpacesInLastNode.IsEmpty()); MOZ_ASSERT(startToDelete.ContainerAsText() == endToDelete.ContainerAsText()); nsresult rv = ReplaceTextWithTransaction( MOZ_KnownLive(*startToDelete.ContainerAsText()), startToDelete.Offset(), endToDelete.Offset() - startToDelete.Offset(), normalizedWhiteSpacesInLastNode); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::ReplaceTextWithTransaction() failed"); return Err(rv); } break; } if (!newCaretPosition.IsSetAndValid() || !newCaretPosition.GetContainer()->IsInComposedDoc()) { NS_WARNING( "HTMLEditor::DeleteTextAndNormalizeSurroundingWhiteSpaces() got lost " "the modifying line"); return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } // Look for leaf node to put caret if we remove some empty inline ancestors // at new caret position. if (!newCaretPosition.IsInTextNode()) { if (nsIContent* currentBlock = HTMLEditUtils:: GetInclusiveAncestorEditableBlockElementOrInlineEditingHost( *newCaretPosition.ContainerAsContent())) { Element* editingHost = GetActiveEditingHost(); // Try to put caret next to immediately after previous editable leaf. nsIContent* previousContent = HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement( newCaretPosition, *currentBlock, editingHost); if (previousContent && !HTMLEditUtils::IsBlockElement(*previousContent)) { newCaretPosition = previousContent->IsText() || HTMLEditUtils::IsContainerNode(*previousContent) ? EditorDOMPoint::AtEndOf(*previousContent) : EditorDOMPoint::After(*previousContent); } // But if the point is very first of a block element or immediately after // a child block, look for next editable leaf instead. else if (nsIContent* nextContent = HTMLEditUtils::GetNextLeafContentOrNextBlockElement( newCaretPosition, *currentBlock, editingHost)) { newCaretPosition = nextContent->IsText() || HTMLEditUtils::IsContainerNode(*nextContent) ? EditorDOMPoint(nextContent, 0) : EditorDOMPoint(nextContent); } } } // For compatibility with Blink, we should move caret to end of previous // text node if it's direct previous sibling of the first text node in the // range. if (newCaretPosition.IsStartOfContainer() && newCaretPosition.IsInTextNode() && newCaretPosition.GetContainer()->GetPreviousSibling() && newCaretPosition.GetContainer()->GetPreviousSibling()->IsText()) { newCaretPosition.SetToEndOf( newCaretPosition.GetContainer()->GetPreviousSibling()->AsText()); } { AutoTrackDOMPoint trackingNewCaretPosition(RangeUpdaterRef(), &newCaretPosition); nsresult rv = InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( newCaretPosition); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::" "InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary() failed"); return Err(rv); } } if (!newCaretPosition.IsSetAndValid()) { NS_WARNING("Inserting
element caused unexpected DOM tree"); return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } return newCaretPosition; } nsresult HTMLEditor::InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( const EditorDOMPoint& aPointToInsert) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aPointToInsert.IsSet()); if (!aPointToInsert.GetContainerAsContent()) { return NS_OK; } // If container of the point is not in a block, we don't need to put a // `
` element here. if (!HTMLEditUtils::IsBlockElement(*aPointToInsert.ContainerAsContent())) { return NS_OK; } WSRunScanner wsRunScanner(*this, aPointToInsert); // If the point is not start of a hard line, we don't need to put a `
` // element here. if (!wsRunScanner.StartsFromHardLineBreak()) { return NS_OK; } // If the point is not end of a hard line or the hard line does not end with // block boundary, we don't need to put a `
` element here. if (!wsRunScanner.EndsByBlockBoundary()) { return NS_OK; } // If we cannot insert a `
` element here, do nothing. if (!HTMLEditUtils::CanNodeContain(*aPointToInsert.GetContainer(), *nsGkAtoms::br)) { return NS_OK; } RefPtr brElement = InsertBRElementWithTransaction(aPointToInsert, nsIEditor::ePrevious); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION(brElement, "HTMLEditor::InsertBRElementWithTransaction() failed"); return brElement ? NS_OK : NS_ERROR_FAILURE; } EditorDOMPoint HTMLEditor::GetGoodCaretPointFor( nsIContent& aContent, nsIEditor::EDirection aDirectionAndAmount) const { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aDirectionAndAmount == nsIEditor::eNext || aDirectionAndAmount == nsIEditor::eNextWord || aDirectionAndAmount == nsIEditor::ePrevious || aDirectionAndAmount == nsIEditor::ePreviousWord || aDirectionAndAmount == nsIEditor::eToBeginningOfLine || aDirectionAndAmount == nsIEditor::eToEndOfLine); bool goingForward = (aDirectionAndAmount == nsIEditor::eNext || aDirectionAndAmount == nsIEditor::eNextWord || aDirectionAndAmount == nsIEditor::eToEndOfLine); // XXX Why don't we check whether the candidate position is enable or not? // When the result is not editable point, caret will be enclosed in // the non-editable content. // If we can put caret in aContent, return start or end in it. if (aContent.IsText() || HTMLEditUtils::IsContainerNode(aContent) || NS_WARN_IF(!aContent.GetParentNode())) { return EditorDOMPoint(&aContent, goingForward ? 0 : aContent.Length()); } // If we are going forward, put caret at aContent itself. if (goingForward) { return EditorDOMPoint(&aContent); } // If we are going backward, put caret to next node unless aContent is an // invisible `
` element. // XXX Shouldn't we put caret to first leaf of the next node? if (!aContent.IsHTMLElement(nsGkAtoms::br) || IsVisibleBRElement(&aContent)) { EditorDOMPoint ret(EditorDOMPoint::After(aContent)); NS_WARNING_ASSERTION(ret.IsSet(), "Failed to set after aContent"); return ret; } // Otherwise, we should put caret at the invisible `
` element. return EditorDOMPoint(&aContent); } EditActionResult HTMLEditor::MakeOrChangeListAndListItemAsSubAction( nsAtom& aListElementOrListItemElementTagName, const nsAString& aBulletType, SelectAllOfCurrentList aSelectAllOfCurrentList) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(&aListElementOrListItemElementTagName == nsGkAtoms::ul || &aListElementOrListItemElementTagName == nsGkAtoms::ol || &aListElementOrListItemElementTagName == nsGkAtoms::dl || &aListElementOrListItemElementTagName == nsGkAtoms::dd || &aListElementOrListItemElementTagName == nsGkAtoms::dt); if (NS_WARN_IF(!mInitSucceeded)) { return EditActionIgnored(NS_ERROR_NOT_INITIALIZED); } EditActionResult result = CanHandleHTMLEditSubAction(); if (result.Failed() || result.Canceled()) { NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::CanHandleHTMLEditSubAction() failed"); return result; } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Some selection containers are not content node, but ignored"); return EditActionIgnored(); } AutoPlaceholderBatch treatAsOneTransaction(*this, ScrollSelectionIntoView::Yes); // XXX EditSubAction::eCreateOrChangeDefinitionListItem and // EditSubAction::eCreateOrChangeList are treated differently in // HTMLEditor::MaybeSplitElementsAtEveryBRElement(). Only when // EditSubAction::eCreateOrChangeList, it splits inline nodes. // Currently, it shouldn't be done when we called for formatting // `

` or `

` by // HTMLEditor::MakeDefinitionListItemWithTransaction(). But this // difference may be a bug. We should investigate this later. IgnoredErrorResult ignoredError; AutoEditSubActionNotifier startToHandleEditSubAction( *this, &aListElementOrListItemElementTagName == nsGkAtoms::dd || &aListElementOrListItemElementTagName == nsGkAtoms::dt ? EditSubAction::eCreateOrChangeDefinitionListItem : EditSubAction::eCreateOrChangeList, nsIEditor::eNext, ignoredError); if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { return EditActionResult(ignoredError.StealNSResult()); } NS_WARNING_ASSERTION( !ignoredError.Failed(), "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); nsresult rv = EnsureNoPaddingBRElementForEmptyEditor(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() " "failed, but ignored"); if (NS_SUCCEEDED(rv) && SelectionRefPtr()->IsCollapsed()) { nsresult rv = EnsureCaretNotAfterPaddingBRElement(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::EnsureCaretNotAfterPaddingBRElement() " "failed, but ignored"); if (NS_SUCCEEDED(rv)) { nsresult rv = PrepareInlineStylesForCaret(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored"); } } nsAtom* listTagName = nullptr; nsAtom* listItemTagName = nullptr; if (&aListElementOrListItemElementTagName == nsGkAtoms::ul || &aListElementOrListItemElementTagName == nsGkAtoms::ol) { listTagName = &aListElementOrListItemElementTagName; listItemTagName = nsGkAtoms::li; } else if (&aListElementOrListItemElementTagName == nsGkAtoms::dl) { listTagName = &aListElementOrListItemElementTagName; listItemTagName = nsGkAtoms::dd; } else if (&aListElementOrListItemElementTagName == nsGkAtoms::dd || &aListElementOrListItemElementTagName == nsGkAtoms::dt) { listTagName = nsGkAtoms::dl; listItemTagName = &aListElementOrListItemElementTagName; } else { NS_WARNING( "aListElementOrListItemElementTagName was neither list element name " "nor " "definition listitem element name"); return EditActionResult(NS_ERROR_INVALID_ARG); } // Expands selection range to include the immediate block parent, and then // further expands to include any ancestors whose children are all in the // range. if (!SelectionRefPtr()->IsCollapsed()) { nsresult rv = MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::MaybeExtendSelectionToHardLineEdgesForBlockEditAction() " "failed"); return EditActionResult(rv); } } // ChangeSelectedHardLinesToList() creates AutoSelectionRestorer. // Therefore, even if it returns NS_OK, editor might have been destroyed // at restoring Selection. result = ChangeSelectedHardLinesToList(MOZ_KnownLive(*listTagName), MOZ_KnownLive(*listItemTagName), aBulletType, aSelectAllOfCurrentList); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::ChangeSelectedHardLinesToList() failed"); return result; } EditActionResult HTMLEditor::ChangeSelectedHardLinesToList( nsAtom& aListElementTagName, nsAtom& aListItemElementTagName, const nsAString& aBulletType, SelectAllOfCurrentList aSelectAllOfCurrentList) { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); AutoSelectionRestorer restoreSelectionLater(*this); AutoTArray, 64> arrayOfContents; Element* parentListElement = aSelectAllOfCurrentList == SelectAllOfCurrentList::Yes ? GetParentListElementAtSelection() : nullptr; if (parentListElement) { arrayOfContents.AppendElement( OwningNonNull(*parentListElement)); } else { AutoTransactionsConserveSelection dontChangeMySelection(*this); nsresult rv = SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges( arrayOfContents, EditSubAction::eCreateOrChangeList, CollectNonEditableNodes::No); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::" "SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges(" "eCreateOrChangeList, CollectNonEditableNodes::No) failed"); return EditActionResult(rv); } } // check if all our nodes are
s, or empty inlines bool bOnlyBreaks = true; for (auto& content : arrayOfContents) { // if content is not a Break or empty inline, we're done if (!content->IsHTMLElement(nsGkAtoms::br) && !IsEmptyInlineNode(content)) { bOnlyBreaks = false; break; } } // if no nodes, we make empty list. Ditto if the user tried to make a list // of some # of breaks. if (arrayOfContents.IsEmpty() || bOnlyBreaks) { // if only breaks, delete them if (bOnlyBreaks) { for (auto& content : arrayOfContents) { // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return EditActionResult(rv); } } } const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return EditActionResult(NS_ERROR_FAILURE); } EditorDOMPoint atStartOfSelection(firstRange->StartRef()); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return EditActionResult(NS_ERROR_FAILURE); } // Make sure we can put a list here. if (!HTMLEditUtils::CanNodeContain(*atStartOfSelection.GetContainer(), aListElementTagName)) { return EditActionCanceled(); } SplitNodeResult splitAtSelectionStartResult = MaybeSplitAncestorsForInsertWithTransaction(aListElementTagName, atStartOfSelection); if (splitAtSelectionStartResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() failed"); return EditActionResult(splitAtSelectionStartResult.Rv()); } RefPtr theList = CreateNodeWithTransaction( aListElementTagName, splitAtSelectionStartResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!theList) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } RefPtr theListItem = CreateNodeWithTransaction( aListItemElementTagName, EditorDOMPoint(theList, 0)); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!theListItem) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } // remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = theListItem; // Put selection in new list item and don't restore the Selection. restoreSelectionLater.Abort(); nsresult rv = CollapseSelectionToStartOf(*theListItem); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return EditActionResult(rv); } // if there is only one node in the array, and it is a list, div, or // blockquote, then look inside of it until we find inner list or content. if (arrayOfContents.Length() == 1) { if (Element* deepestDivBlockquoteOrListElement = GetDeepestEditableOnlyChildDivBlockquoteOrListElement( arrayOfContents[0])) { if (deepestDivBlockquoteOrListElement->IsAnyOfHTMLElements( nsGkAtoms::div, nsGkAtoms::blockquote)) { arrayOfContents.Clear(); CollectChildren(*deepestDivBlockquoteOrListElement, arrayOfContents, 0, CollectListChildren::No, CollectTableChildren::No, CollectNonEditableNodes::Yes); } else { arrayOfContents.ReplaceElementAt( 0, OwningNonNull(*deepestDivBlockquoteOrListElement)); } } } // Ok, now go through all the nodes and put then in the list, // or whatever is approriate. Wohoo! uint32_t countOfCollectedContents = arrayOfContents.Length(); RefPtr curList, prevListItem; for (uint32_t i = 0; i < countOfCollectedContents; i++) { // here's where we actually figure out what to do OwningNonNull content = arrayOfContents[i]; // make sure we don't assemble content that is in different table cells // into the same list. respect table cell boundaries when listifying. if (curList && HTMLEditor::NodesInDifferentTableElements(*curList, content)) { curList = nullptr; } // If current node is a `
` element, delete it and forget previous // list item element. // If current node is an empty inline node, just delete it. if (EditorUtils::IsEditableContent(content, EditorType::HTML) && (content->IsHTMLElement(nsGkAtoms::br) || IsEmptyInlineNode(content))) { nsresult rv = DeleteNodeWithTransaction(*content); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return EditActionResult(rv); } if (content->IsHTMLElement(nsGkAtoms::br)) { prevListItem = nullptr; } continue; } if (HTMLEditUtils::IsAnyListElement(content)) { // If we met a list element and current list element is not a descendant // of the list, append current node to end of the current list element. // Then, wrap it with list item element and delete the old container. if (curList && !EditorUtils::IsDescendantOf(*content, *curList)) { nsresult rv = MoveNodeToEndWithTransaction(*content, *curList); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return EditActionResult(rv); } CreateElementResult convertListTypeResult = ChangeListElementType(MOZ_KnownLive(*content->AsElement()), aListElementTagName, aListItemElementTagName); if (convertListTypeResult.Failed()) { NS_WARNING("HTMLEditor::ChangeListElementType() failed"); return EditActionResult(convertListTypeResult.Rv()); } rv = RemoveBlockContainerWithTransaction( MOZ_KnownLive(*convertListTypeResult.GetNewNode())); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return EditActionResult(rv); } prevListItem = nullptr; continue; } // If current list element is in found list element or we've not met a // list element, convert current list element to proper type. CreateElementResult convertListTypeResult = ChangeListElementType(MOZ_KnownLive(*content->AsElement()), aListElementTagName, aListItemElementTagName); if (convertListTypeResult.Failed()) { NS_WARNING("HTMLEditor::ChangeListElementType() failed"); return EditActionResult(convertListTypeResult.Rv()); } curList = convertListTypeResult.forget(); prevListItem = nullptr; continue; } EditorDOMPoint atContent(content); if (NS_WARN_IF(!atContent.IsSet())) { return EditActionResult(NS_ERROR_FAILURE); } MOZ_ASSERT(atContent.IsSetAndValid()); if (HTMLEditUtils::IsListItem(content)) { // If current list item element is not in proper list element, we need // to conver the list element. if (!atContent.IsContainerHTMLElement(&aListElementTagName)) { // If we've not met a list element or current node is not in current // list element, insert a list element at current node and set // current list element to the new one. if (!curList || EditorUtils::IsDescendantOf(*content, *curList)) { if (NS_WARN_IF(!atContent.GetContainerAsContent())) { return EditActionResult(NS_ERROR_FAILURE); } ErrorResult error; nsCOMPtr newLeftNode = SplitNodeWithTransaction(atContent, error); if (NS_WARN_IF(Destroyed())) { error.SuppressException(); return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (error.Failed()) { NS_WARNING("HTMLEditor::SplitNodeWithTransaction() failed"); return EditActionResult(error.StealNSResult()); } curList = CreateNodeWithTransaction( aListElementTagName, EditorDOMPoint(atContent.GetContainer())); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!curList) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } } // Then, move current node into current list element. nsresult rv = MoveNodeToEndWithTransaction(*content, *curList); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return EditActionResult(rv); } // Convert list item type if current node is different list item type. if (!content->IsHTMLElement(&aListItemElementTagName)) { RefPtr newListItemElement = ReplaceContainerWithTransaction( MOZ_KnownLive(*content->AsElement()), aListItemElementTagName); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!newListItemElement) { NS_WARNING("HTMLEditor::ReplaceContainerWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } } } else { // If we've not met a list element, set current list element to the // parent of current list item element. if (!curList) { curList = atContent.GetContainerAsElement(); NS_WARNING_ASSERTION( HTMLEditUtils::IsAnyListElement(curList), "Current list item parent is not a list element"); } // If current list item element is not a child of current list element, // move it into current list item. else if (atContent.GetContainer() != curList) { nsresult rv = MoveNodeToEndWithTransaction(*content, *curList); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return EditActionResult(rv); } } // Then, if current list item element is not proper type for current // list element, convert list item element to proper element. if (!content->IsHTMLElement(&aListItemElementTagName)) { RefPtr newListItemElement = ReplaceContainerWithTransaction( MOZ_KnownLive(*content->AsElement()), aListItemElementTagName); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!newListItemElement) { NS_WARNING("HTMLEditor::ReplaceContainerWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } } } Element* element = Element::FromNode(content); if (NS_WARN_IF(!element)) { return EditActionResult(NS_ERROR_FAILURE); } // If bullet type is specified, set list type attribute. // XXX Cannot we set type attribute before inserting the list item // element into the DOM tree? if (!aBulletType.IsEmpty()) { nsresult rv = SetAttributeWithTransaction( MOZ_KnownLive(*element), *nsGkAtoms::type, aBulletType); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING( "EditorBase::SetAttributeWithTransaction(nsGkAtoms::type) " "failed"); return EditActionResult(rv); } continue; } // Otherwise, remove list type attribute if there is. if (!element->HasAttr(nsGkAtoms::type)) { continue; } nsresult rv = RemoveAttributeWithTransaction(MOZ_KnownLive(*element), *nsGkAtoms::type); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING( "EditorBase::RemoveAttributeWithTransaction(nsGkAtoms::type) " "failed"); return EditActionResult(rv); } continue; } MOZ_ASSERT(!HTMLEditUtils::IsAnyListElement(content) && !HTMLEditUtils::IsListItem(content)); // If current node is a `

` element, replace it in the array with // its children. // XXX I think that this should be done when we collect the nodes above. // Then, we can change this `for` loop to ranged-for loop. if (content->IsHTMLElement(nsGkAtoms::div)) { prevListItem = nullptr; CollectChildren(*content, arrayOfContents, i + 1, CollectListChildren::Yes, CollectTableChildren::Yes, CollectNonEditableNodes::Yes); nsresult rv = RemoveContainerWithTransaction(MOZ_KnownLive(*content->AsElement())); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RemoveContainerWithTransaction() failed"); return EditActionResult(rv); } // Extend the loop length to handle all children collected here. countOfCollectedContents = arrayOfContents.Length(); continue; } // If we've not met a list element, create a list element and make it // current list element. if (!curList) { SplitNodeResult splitCurNodeResult = MaybeSplitAncestorsForInsertWithTransaction(aListElementTagName, atContent); if (splitCurNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() failed"); return EditActionResult(splitCurNodeResult.Rv()); } prevListItem = nullptr; curList = CreateNodeWithTransaction(aListElementTagName, splitCurNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!curList) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } // Set new block element of top level edit sub-action to the new list // element for setting selection into it. // XXX This must be wrong. If we're handling nested edit action, // we shouldn't overwrite the new block element. TopLevelEditSubActionDataRef().mNewBlockElement = curList; // atContent is now referring the right node with mOffset but // referring the left node with mRef. So, invalidate it now. atContent.Clear(); } // If we're currently handling contents of a list item and current node // is not a block element, move current node into the list item. if (HTMLEditUtils::IsInlineElement(content) && prevListItem) { nsresult rv = MoveNodeToEndWithTransaction(*content, *prevListItem); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return EditActionResult(rv); } continue; } // If current node is a paragraph, that means that it does not contain // block children so that we can just replace it with new list item // element and move it into current list element. // XXX This is too rough handling. If web apps modifies DOM tree directly, // any elements can have block elements as children. if (content->IsHTMLElement(nsGkAtoms::p)) { RefPtr newListItemElement = ReplaceContainerWithTransaction( MOZ_KnownLive(*content->AsElement()), aListItemElementTagName); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!newListItemElement) { NS_WARNING("HTMLEditor::ReplaceContainerWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } prevListItem = nullptr; nsresult rv = MoveNodeToEndWithTransaction(*newListItemElement, *curList); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return EditActionResult(rv); } // XXX Why don't we set `type` attribute here?? continue; } // If current node is not a paragraph, wrap current node with new list // item element and move it into current list element. RefPtr newListItemElement = InsertContainerWithTransaction(*content, aListItemElementTagName); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!newListItemElement) { NS_WARNING("HTMLEditor::InsertContainerWithTransaction() failed"); return EditActionResult(NS_ERROR_FAILURE); } // If current node is not a block element, new list item should have // following inline nodes too. if (HTMLEditUtils::IsInlineElement(content)) { prevListItem = newListItemElement; } else { prevListItem = nullptr; } nsresult rv = MoveNodeToEndWithTransaction(*newListItemElement, *curList); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return EditActionResult(rv); } // XXX Why don't we set `type` attribute here?? } return EditActionHandled(); } nsresult HTMLEditor::RemoveListAtSelectionAsSubAction() { MOZ_ASSERT(IsEditActionDataAvailable()); EditActionResult result = CanHandleHTMLEditSubAction(); if (result.Failed() || result.Canceled()) { NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::CanHandleHTMLEditSubAction() failed"); return result.Rv(); } AutoPlaceholderBatch treatAsOneTransaction(*this, ScrollSelectionIntoView::Yes); IgnoredErrorResult ignoredError; AutoEditSubActionNotifier startToHandleEditSubAction( *this, EditSubAction::eRemoveList, nsIEditor::eNext, ignoredError); if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { return ignoredError.StealNSResult(); } NS_WARNING_ASSERTION( !ignoredError.Failed(), "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); if (!SelectionRefPtr()->IsCollapsed()) { nsresult rv = MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::MaybeExtendSelectionToHardLineEdgesForBlockEditAction() " "failed"); return rv; } } AutoSelectionRestorer restoreSelectionLater(*this); AutoTArray, 64> arrayOfContents; { AutoTransactionsConserveSelection dontChangeMySelection(*this); nsresult rv = SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges( arrayOfContents, EditSubAction::eCreateOrChangeList, CollectNonEditableNodes::No); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::" "SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges(" "eCreateOrChangeList, CollectNonEditableNodes::No) failed"); return rv; } } // Remove all non-editable nodes. Leave them be. // XXX SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges() // should return only editable contents when it's called with // CollectNonEditableNodes::No. for (int32_t i = arrayOfContents.Length() - 1; i >= 0; i--) { OwningNonNull& content = arrayOfContents[i]; if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { arrayOfContents.RemoveElementAt(i); } } // Only act on lists or list items in the array for (auto& content : arrayOfContents) { // here's where we actually figure out what to do if (HTMLEditUtils::IsListItem(content)) { // unlist this listitem nsresult rv = LiftUpListItemElement(MOZ_KnownLive(*content->AsElement()), LiftUpFromAllParentListElements::Yes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::LiftUpListItemElement(LiftUpFromAllParentListElements:" ":Yes) failed"); return rv; } continue; } if (HTMLEditUtils::IsAnyListElement(content)) { // node is a list, move list items out nsresult rv = DestroyListStructureRecursively(MOZ_KnownLive(*content->AsElement())); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DestroyListStructureRecursively() failed"); return rv; } continue; } } return NS_OK; } nsresult HTMLEditor::FormatBlockContainerWithTransaction(nsAtom& blockType) { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); if (!SelectionRefPtr()->IsCollapsed()) { nsresult rv = MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::MaybeExtendSelectionToHardLineEdgesForBlockEditAction() " "failed"); return rv; } } AutoSelectionRestorer restoreSelectionLater(*this); AutoTransactionsConserveSelection dontChangeMySelection(*this); AutoTArray, 64> arrayOfContents; nsresult rv = SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges( arrayOfContents, EditSubAction::eCreateOrRemoveBlock, CollectNonEditableNodes::Yes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::" "SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges(" "eCreateOrRemoveBlock, CollectNonEditableNodes::Yes) failed"); return rv; } // If there is no visible and editable nodes in the edit targets, make an // empty block. // XXX Isn't this odd if there are only non-editable visible nodes? if (IsEmptyOneHardLine(arrayOfContents)) { const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return NS_ERROR_FAILURE; } EditorDOMPoint pointToInsertBlock(firstRange->StartRef()); if (&blockType == nsGkAtoms::normal || &blockType == nsGkAtoms::_empty) { if (!pointToInsertBlock.IsInContentNode()) { NS_WARNING( "HTMLEditor::FormatBlockContainerWithTransaction() couldn't find " "block parent because container of the point is not content"); return NS_ERROR_FAILURE; } // We are removing blocks (going to "body text") RefPtr blockElement = HTMLEditUtils::GetInclusiveAncestorBlockElement( *pointToInsertBlock.ContainerAsContent()); if (!blockElement) { NS_WARNING( "HTMLEditor::FormatBlockContainerWithTransaction() couldn't find " "block parent"); return NS_ERROR_FAILURE; } if (!HTMLEditUtils::IsFormatNode(blockElement)) { return NS_OK; } // If the first editable node after selection is a br, consume it. // Otherwise it gets pushed into a following block after the split, // which is visually bad. nsCOMPtr brContent = GetNextEditableHTMLNode(pointToInsertBlock); if (brContent && brContent->IsHTMLElement(nsGkAtoms::br)) { AutoEditorDOMPointChildInvalidator lockOffset(pointToInsertBlock); rv = DeleteNodeWithTransaction(*brContent); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } } // Do the splits! SplitNodeResult splitNodeResult = SplitNodeDeepWithTransaction( *blockElement, pointToInsertBlock, SplitAtEdges::eDoNotCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (splitNodeResult.Failed()) { NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed"); return splitNodeResult.Rv(); } EditorDOMPoint pointToInsertBRNode(splitNodeResult.SplitPoint()); // Put a
element at the split point brContent = InsertBRElementWithTransaction(pointToInsertBRNode); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!brContent) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return NS_ERROR_FAILURE; } // Don't restore the selection restoreSelectionLater.Abort(); // Put selection at the split point nsresult rv = CollapseSelectionTo(EditorRawDOMPoint(brContent)); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } // We are making a block. Consume a br, if needed. nsCOMPtr brNode = GetNextEditableHTMLNodeInBlock(pointToInsertBlock); if (brNode && brNode->IsHTMLElement(nsGkAtoms::br)) { AutoEditorDOMPointChildInvalidator lockOffset(pointToInsertBlock); rv = DeleteNodeWithTransaction(*brNode); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } // We don't need to act on this node any more arrayOfContents.RemoveElement(brNode); } // Make sure we can put a block here. SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(blockType, pointToInsertBlock); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() failed"); return splitNodeResult.Rv(); } RefPtr block = CreateNodeWithTransaction(blockType, splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!block) { NS_WARNING("CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // Remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = block; // Delete anything that was in the list of nodes while (!arrayOfContents.IsEmpty()) { OwningNonNull& content = arrayOfContents[0]; // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } arrayOfContents.RemoveElementAt(0); } // Don't restore the selection restoreSelectionLater.Abort(); // Put selection in new block rv = CollapseSelectionToStartOf(*block); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } // Okay, now go through all the nodes and make the right kind of blocks, or // whatever is approriate. Woohoo! Note: blockquote is handled a little // differently. if (&blockType == nsGkAtoms::blockquote) { nsresult rv = MoveNodesIntoNewBlockquoteElement(arrayOfContents); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::MoveNodesIntoNewBlockquoteElement() failed"); return rv; } if (&blockType == nsGkAtoms::normal || &blockType == nsGkAtoms::_empty) { nsresult rv = RemoveBlockContainerElements(arrayOfContents); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::RemoveBlockContainerElements() failed"); return rv; } rv = CreateOrChangeBlockContainerElement(arrayOfContents, blockType); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::CreateOrChangeBlockContainerElement() failed"); return rv; } nsresult HTMLEditor::MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); if (!SelectionRefPtr()->IsCollapsed()) { return NS_OK; } const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return NS_ERROR_FAILURE; } const RangeBoundary& atStartOfSelection = firstRange->StartRef(); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return NS_ERROR_FAILURE; } if (!atStartOfSelection.Container()->IsElement()) { return NS_OK; } OwningNonNull startContainerElement = *atStartOfSelection.Container()->AsElement(); nsresult rv = InsertPaddingBRElementForEmptyLastLineIfNeeded(startContainerElement); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::InsertPaddingBRElementForEmptyLastLineIfNeeded() failed"); return rv; } EditActionResult HTMLEditor::IndentAsSubAction() { MOZ_ASSERT(IsEditActionDataAvailable()); AutoPlaceholderBatch treatAsOneTransaction(*this, ScrollSelectionIntoView::Yes); IgnoredErrorResult ignoredError; AutoEditSubActionNotifier startToHandleEditSubAction( *this, EditSubAction::eIndent, nsIEditor::eNext, ignoredError); if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { return EditActionResult(ignoredError.StealNSResult()); } NS_WARNING_ASSERTION( !ignoredError.Failed(), "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); EditActionResult result = CanHandleHTMLEditSubAction(); if (result.Failed() || result.Canceled()) { NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::CanHandleHTMLEditSubAction() failed"); return result; } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Some selection containers are not content node, but ignored"); return EditActionIgnored(); } result |= HandleIndentAtSelection(); if (result.Failed() || result.Canceled()) { NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::HandleIndentAtSelection() failed"); return result; } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Mutation event listener might have changed selection"); return EditActionHandled(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } nsresult rv = MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() failed"); return result.SetResult(rv); } // Helper for Handle[CSS|HTML]IndentAtSelectionInternal nsresult HTMLEditor::IndentListChild(RefPtr* aCurList, const EditorDOMPoint& aCurPoint, nsIContent& aContent) { MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(aCurPoint.GetContainer()), "unexpected container"); MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); // some logic for putting list items into nested lists... // Check for whether we should join a list that follows aContent. // We do this if the next element is a list, and the list is of the // same type (li/ol) as aContent was a part it. if (nsIContent* nextEditableSibling = GetNextHTMLSibling(&aContent, SkipWhiteSpace::Yes)) { if (HTMLEditUtils::IsAnyListElement(nextEditableSibling) && aCurPoint.GetContainer()->NodeInfo()->NameAtom() == nextEditableSibling->NodeInfo()->NameAtom() && aCurPoint.GetContainer()->NodeInfo()->NamespaceID() == nextEditableSibling->NodeInfo()->NamespaceID()) { nsresult rv = MoveNodeWithTransaction( aContent, EditorDOMPoint(nextEditableSibling, 0)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "EdigtorBase::MoveNodeWithTransaction() failed"); return rv; } } // Check for whether we should join a list that preceeds aContent. // We do this if the previous element is a list, and the list is of // the same type (li/ol) as aContent was a part of. if (nsCOMPtr previousEditableSibling = GetPriorHTMLSibling(&aContent, SkipWhiteSpace::Yes)) { if (HTMLEditUtils::IsAnyListElement(previousEditableSibling) && aCurPoint.GetContainer()->NodeInfo()->NameAtom() == previousEditableSibling->NodeInfo()->NameAtom() && aCurPoint.GetContainer()->NodeInfo()->NamespaceID() == previousEditableSibling->NodeInfo()->NamespaceID()) { nsresult rv = MoveNodeToEndWithTransaction(aContent, *previousEditableSibling); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } } // check to see if aCurList is still appropriate. Which it is if // aContent is still right after it in the same list. nsIContent* previousEditableSibling = *aCurList ? GetPriorHTMLSibling(&aContent, SkipWhiteSpace::Yes) : nullptr; if (!*aCurList || (previousEditableSibling && previousEditableSibling != *aCurList)) { nsAtom* containerName = aCurPoint.GetContainer()->NodeInfo()->NameAtom(); // Create a new nested list of correct type. SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction( MOZ_KnownLive(*containerName), aCurPoint); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() failed"); return splitNodeResult.Rv(); } *aCurList = CreateNodeWithTransaction(MOZ_KnownLive(*containerName), splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!*aCurList) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // aCurList is now the correct thing to put aContent in // remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = *aCurList; } // tuck the node into the end of the active list RefPtr container = *aCurList; nsresult rv = MoveNodeToEndWithTransaction(aContent, *container); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } EditActionResult HTMLEditor::HandleIndentAtSelection() { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); nsresult rv = EnsureNoPaddingBRElementForEmptyEditor(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() " "failed, but ignored"); if (NS_SUCCEEDED(rv) && SelectionRefPtr()->IsCollapsed()) { nsresult rv = EnsureCaretNotAfterPaddingBRElement(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::EnsureCaretNotAfterPaddingBRElement() " "failed, but ignored"); if (NS_SUCCEEDED(rv)) { nsresult rv = PrepareInlineStylesForCaret(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored"); } } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Mutation event listener might have changed the selection"); return EditActionHandled(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } if (IsCSSEnabled()) { nsresult rv = HandleCSSIndentAtSelection(); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::HandleCSSIndentAtSelection() failed"); return EditActionHandled(rv); } rv = HandleHTMLIndentAtSelection(); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::HandleHTMLIndent() failed"); return EditActionHandled(rv); } nsresult HTMLEditor::HandleCSSIndentAtSelection() { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); if (!SelectionRefPtr()->IsCollapsed()) { nsresult rv = MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::MaybeExtendSelectionToHardLineEdgesForBlockEditAction() " "failed"); return rv; } } // HandleCSSIndentAtSelectionInternal() creates AutoSelectionRestorer. // Therefore, even if it returns NS_OK, editor might have been destroyed // at restoring Selection. nsresult rv = HandleCSSIndentAtSelectionInternal(); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::HandleCSSIndentAtSelectionInternal() failed"); return rv; } nsresult HTMLEditor::HandleCSSIndentAtSelectionInternal() { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); AutoSelectionRestorer restoreSelectionLater(*this); AutoTArray, 64> arrayOfContents; // short circuit: detect case of collapsed selection inside an

. // just sublist that

. This prevents bug 97797. if (SelectionRefPtr()->IsCollapsed()) { EditorRawDOMPoint atCaret(EditorBase::GetStartPoint(*SelectionRefPtr())); if (NS_WARN_IF(!atCaret.IsSet())) { return NS_ERROR_FAILURE; } MOZ_ASSERT(atCaret.IsInContentNode()); Element* blockElement = HTMLEditUtils::GetInclusiveAncestorBlockElement( *atCaret.ContainerAsContent()); if (blockElement && HTMLEditUtils::IsListItem(blockElement)) { arrayOfContents.AppendElement(*blockElement); } } if (arrayOfContents.IsEmpty()) { nsresult rv = SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges( arrayOfContents, EditSubAction::eIndent, CollectNonEditableNodes::Yes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::" "SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges(" "eIndent, CollectNonEditableNodes::Yes) failed"); return rv; } } // If there is no visible and editable nodes in the edit targets, make an // empty block. // XXX Isn't this odd if there are only non-editable visible nodes? if (IsEmptyOneHardLine(arrayOfContents)) { // get selection location const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return NS_ERROR_FAILURE; } EditorDOMPoint atStartOfSelection(firstRange->StartRef()); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return NS_ERROR_FAILURE; } // make sure we can put a block here SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(*nsGkAtoms::div, atStartOfSelection); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction(nsGkAtoms::" "div) failed"); return splitNodeResult.Rv(); } RefPtr theBlock = CreateNodeWithTransaction( *nsGkAtoms::div, splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!theBlock) { NS_WARNING( "EditorBase::CreateNodeWithTransaction(nsGkAtoms::div) failed"); return NS_ERROR_FAILURE; } // remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = theBlock; nsresult rv = ChangeMarginStart(*theBlock, ChangeMargin::Increase); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::ChangeMarginStart() failed, but ignored"); // delete anything that was in the list of nodes // XXX We don't need to remove the nodes from the array for performance. while (!arrayOfContents.IsEmpty()) { OwningNonNull& content = arrayOfContents[0]; // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } arrayOfContents.RemoveElementAt(0); } // Don't restore the selection restoreSelectionLater.Abort(); // put selection in new block rv = CollapseSelectionToStartOf(*theBlock); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } // Ok, now go through all the nodes and put them in a blockquote, // or whatever is appropriate. RefPtr curList, curQuote; for (OwningNonNull& content : arrayOfContents) { // Here's where we actually figure out what to do. EditorDOMPoint atContent(content); if (NS_WARN_IF(!atContent.IsSet())) { continue; } // Ignore all non-editable nodes. Leave them be. // XXX We ignore non-editable nodes here, but not so in the above block. if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { continue; } if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. nsresult rv = IndentListChild(&curList, atContent, MOZ_KnownLive(content)); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::IndentListChild() failed"); return rv; } continue; } // Not a list item. if (HTMLEditUtils::IsBlockElement(content)) { nsresult rv = ChangeMarginStart(MOZ_KnownLive(*content->AsElement()), ChangeMargin::Increase); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::ChangeMarginStart() failed, but ignored"); curQuote = nullptr; continue; } if (!curQuote) { // First, check that our element can contain a div. if (!HTMLEditUtils::CanNodeContain(*atContent.GetContainer(), *nsGkAtoms::div)) { return NS_OK; // cancelled } SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(*nsGkAtoms::div, atContent); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction(nsGkAtoms:" ":div) failed"); return splitNodeResult.Rv(); } curQuote = CreateNodeWithTransaction(*nsGkAtoms::div, splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!curQuote) { NS_WARNING( "EditorBase::CreateNodeWithTransaction(nsGkAtoms::div) failed"); return NS_ERROR_FAILURE; } nsresult rv = ChangeMarginStart(*curQuote, ChangeMargin::Increase); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::ChangeMarginStart() failed, but ignored"); // remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = curQuote; // curQuote is now the correct thing to put content in } // tuck the node into the end of the active blockquote // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. nsresult rv = MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *curQuote); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } } return NS_OK; } nsresult HTMLEditor::HandleHTMLIndentAtSelection() { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); if (!SelectionRefPtr()->IsCollapsed()) { nsresult rv = MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::MaybeExtendSelectionToHardLineEdgesForBlockEditAction() " "failed"); return rv; } } // HandleHTMLIndentAtSelectionInternal() creates AutoSelectionRestorer. // Therefore, even if it returns NS_OK, editor might have been destroyed // at restoring Selection. nsresult rv = HandleHTMLIndentAtSelectionInternal(); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::HandleHTMLIndentAtSelectionInternal() failed"); return rv; } nsresult HTMLEditor::HandleHTMLIndentAtSelectionInternal() { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); AutoSelectionRestorer restoreSelectionLater(*this); // convert the selection ranges into "promoted" selection ranges: // this basically just expands the range to include the immediate // block parent, and then further expands to include any ancestors // whose children are all in the range AutoTArray, 4> arrayOfRanges; GetSelectionRangesExtendedToHardLineStartAndEnd(arrayOfRanges, EditSubAction::eIndent); // use these ranges to construct a list of nodes to act on. AutoTArray, 64> arrayOfContents; nsresult rv = SplitInlinesAndCollectEditTargetNodes( arrayOfRanges, arrayOfContents, EditSubAction::eIndent, CollectNonEditableNodes::Yes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::SplitInlinesAndCollectEditTargetNodes(eIndent, " "CollectNonEditableNodes::Yes) failed"); return rv; } // If there is no visible and editable nodes in the edit targets, make an // empty block. // XXX Isn't this odd if there are only non-editable visible nodes? if (IsEmptyOneHardLine(arrayOfContents)) { const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return NS_ERROR_FAILURE; } EditorDOMPoint atStartOfSelection(firstRange->StartRef()); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return NS_ERROR_FAILURE; } // Make sure we can put a block here. SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(*nsGkAtoms::blockquote, atStartOfSelection); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction(nsGkAtoms::" "blockquote) failed"); return splitNodeResult.Rv(); } RefPtr theBlock = CreateNodeWithTransaction( *nsGkAtoms::blockquote, splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!theBlock) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = theBlock; // delete anything that was in the list of nodes // XXX We don't need to remove the nodes from the array for performance. while (!arrayOfContents.IsEmpty()) { OwningNonNull& content = arrayOfContents[0]; // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } arrayOfContents.RemoveElementAt(0); } // Don't restore the selection restoreSelectionLater.Abort(); nsresult rv = CollapseSelectionToStartOf(*theBlock); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } // Ok, now go through all the nodes and put them in a blockquote, // or whatever is appropriate. Wohoo! RefPtr curList, curQuote, indentedLI; for (OwningNonNull& content : arrayOfContents) { // Here's where we actually figure out what to do. EditorDOMPoint atContent(content); if (NS_WARN_IF(!atContent.IsSet())) { continue; } // Ignore all non-editable nodes. Leave them be. // XXX We ignore non-editable nodes here, but not so in the above block. if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { continue; } if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. nsresult rv = IndentListChild(&curList, atContent, MOZ_KnownLive(content)); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::IndentListChild() failed"); return rv; } // forget curQuote, if any curQuote = nullptr; continue; } // Not a list item, use blockquote? // if we are inside a list item, we don't want to blockquote, we want // to sublist the list item. We may have several nodes listed in the // array of nodes to act on, that are in the same list item. Since // we only want to indent that li once, we must keep track of the most // recent indented list item, and not indent it if we find another node // to act on that is still inside the same li. if (RefPtr listItem = GetNearestAncestorListItemElement(content)) { if (indentedLI == listItem) { // already indented this list item continue; } // check to see if curList is still appropriate. Which it is if // content is still right after it in the same list. nsIContent* previousEditableSibling = curList ? GetPriorHTMLSibling(listItem) : nullptr; if (!curList || (previousEditableSibling && previousEditableSibling != curList)) { EditorDOMPoint atListItem(listItem); if (NS_WARN_IF(!listItem)) { return NS_ERROR_FAILURE; } nsAtom* containerName = atListItem.GetContainer()->NodeInfo()->NameAtom(); // Create a new nested list of correct type. SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction( MOZ_KnownLive(*containerName), atListItem); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() " "failed"); return splitNodeResult.Rv(); } curList = CreateNodeWithTransaction(MOZ_KnownLive(*containerName), splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!curList) { NS_WARNING("HTMLEditor::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } } rv = MoveNodeToEndWithTransaction(*listItem, *curList); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } // remember we indented this li indentedLI = listItem; continue; } // need to make a blockquote to put things in if we haven't already, // or if this node doesn't go in blockquote we used earlier. // One reason it might not go in prio blockquote is if we are now // in a different table cell. if (curQuote && HTMLEditor::NodesInDifferentTableElements(*curQuote, content)) { curQuote = nullptr; } if (!curQuote) { // First, check that our element can contain a blockquote. if (!HTMLEditUtils::CanNodeContain(*atContent.GetContainer(), *nsGkAtoms::blockquote)) { return NS_OK; // cancelled } SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(*nsGkAtoms::blockquote, atContent); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction(nsGkAtoms:" ":blockquote) failed"); return splitNodeResult.Rv(); } curQuote = CreateNodeWithTransaction(*nsGkAtoms::blockquote, splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!curQuote) { NS_WARNING( "EditorBase::CreateNodeWithTransaction(nsGkAtoms::blockquote) " "failed"); return NS_ERROR_FAILURE; } // remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = curQuote; // curQuote is now the correct thing to put curNode in } // tuck the node into the end of the active blockquote // MOZ_KnownLive because 'arrayOfContents' is guaranteed to // keep it alive. rv = MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *curQuote); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } // forget curList, if any curList = nullptr; } return NS_OK; } EditActionResult HTMLEditor::OutdentAsSubAction() { MOZ_ASSERT(IsEditActionDataAvailable()); AutoPlaceholderBatch treatAsOneTransaction(*this, ScrollSelectionIntoView::Yes); IgnoredErrorResult ignoredError; AutoEditSubActionNotifier startToHandleEditSubAction( *this, EditSubAction::eOutdent, nsIEditor::eNext, ignoredError); if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { return EditActionResult(ignoredError.StealNSResult()); } NS_WARNING_ASSERTION( !ignoredError.Failed(), "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); EditActionResult result = CanHandleHTMLEditSubAction(); if (result.Failed() || result.Canceled()) { NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::CanHandleHTMLEditSubAction() failed"); return result; } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Some selection containers are not content node, but ignored"); return EditActionIgnored(); } result |= HandleOutdentAtSelection(); if (result.Failed() || result.Canceled()) { NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::HandleOutdentAtSelection() failed"); return result; } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Mutation event listener might have changed the selection"); return EditActionHandled(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } nsresult rv = MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() " "failed"); return result.SetResult(rv); } EditActionResult HTMLEditor::HandleOutdentAtSelection() { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); if (!SelectionRefPtr()->IsCollapsed()) { nsresult rv = MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); if (NS_WARN_IF(NS_FAILED(rv))) { return EditActionHandled(rv); } } // HandleOutdentAtSelectionInternal() creates AutoSelectionRestorer. // Therefore, even if it returns NS_OK, the editor might have been destroyed // at restoring Selection. SplitRangeOffFromNodeResult outdentResult = HandleOutdentAtSelectionInternal(); if (NS_WARN_IF(Destroyed())) { return EditActionHandled(NS_ERROR_EDITOR_DESTROYED); } if (outdentResult.Failed()) { NS_WARNING("HTMLEditor::HandleOutdentAtSelectionInternal() failed"); return EditActionHandled(outdentResult.Rv()); } // Make sure selection didn't stick to last piece of content in old bq (only // a problem for collapsed selections) if (!outdentResult.GetLeftContent() && !outdentResult.GetRightContent()) { return EditActionHandled(); } if (!SelectionRefPtr()->IsCollapsed()) { return EditActionHandled(); } // Push selection past end of left element of last split indented element. if (outdentResult.GetLeftContent()) { const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return EditActionHandled(); } const RangeBoundary& atStartOfSelection = firstRange->StartRef(); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return EditActionHandled(NS_ERROR_FAILURE); } if (atStartOfSelection.Container() == outdentResult.GetLeftContent() || EditorUtils::IsDescendantOf(*atStartOfSelection.Container(), *outdentResult.GetLeftContent())) { // Selection is inside the left node - push it past it. EditorRawDOMPoint afterRememberedLeftBQ( EditorRawDOMPoint::After(*outdentResult.GetLeftContent())); NS_WARNING_ASSERTION( afterRememberedLeftBQ.IsSet(), "Failed to set after remembered left blockquote element"); nsresult rv = CollapseSelectionTo(afterRememberedLeftBQ); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionHandled(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed, but ignored"); } } // And pull selection before beginning of right element of last split // indented element. if (outdentResult.GetRightContent()) { const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return EditActionHandled(); } const RangeBoundary& atStartOfSelection = firstRange->StartRef(); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return EditActionHandled(NS_ERROR_FAILURE); } if (atStartOfSelection.Container() == outdentResult.GetRightContent() || EditorUtils::IsDescendantOf(*atStartOfSelection.Container(), *outdentResult.GetRightContent())) { // Selection is inside the right element - push it before it. EditorRawDOMPoint atRememberedRightBQ(outdentResult.GetRightContent()); nsresult rv = CollapseSelectionTo(atRememberedRightBQ); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionHandled(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed, but ignored"); } } return EditActionHandled(); } SplitRangeOffFromNodeResult HTMLEditor::HandleOutdentAtSelectionInternal() { MOZ_ASSERT(IsEditActionDataAvailable()); AutoSelectionRestorer restoreSelectionLater(*this); bool useCSS = IsCSSEnabled(); // Convert the selection ranges into "promoted" selection ranges: this // basically just expands the range to include the immediate block parent, // and then further expands to include any ancestors whose children are all // in the range AutoTArray, 64> arrayOfContents; nsresult rv = SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges( arrayOfContents, EditSubAction::eOutdent, CollectNonEditableNodes::Yes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::" "SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges() " "failed"); return SplitRangeOffFromNodeResult(rv); } nsCOMPtr leftContentOfLastOutdented; nsCOMPtr middleContentOfLastOutdented; nsCOMPtr rightContentOfLastOutdented; RefPtr indentedParentElement; nsCOMPtr firstContentToBeOutdented, lastContentToBeOutdented; BlockIndentedWith indentedParentIndentedWith = BlockIndentedWith::HTML; for (OwningNonNull& content : arrayOfContents) { // Here's where we actually figure out what to do EditorDOMPoint atContent(content); if (!atContent.IsSet()) { continue; } // If it's a `

`, remove it to outdent its children. if (content->IsHTMLElement(nsGkAtoms::blockquote)) { // If we've already found an ancestor block element indented, we need to // split it and remove the block element first. if (indentedParentElement) { MOZ_ASSERT(indentedParentElement == content); SplitRangeOffFromNodeResult outdentResult = OutdentPartOfBlock( *indentedParentElement, *firstContentToBeOutdented, *lastContentToBeOutdented, indentedParentIndentedWith); if (outdentResult.Failed()) { NS_WARNING("HTMLEditor::OutdentPartOfBlock() failed"); return outdentResult; } leftContentOfLastOutdented = outdentResult.GetLeftContent(); middleContentOfLastOutdented = outdentResult.GetMiddleContent(); rightContentOfLastOutdented = outdentResult.GetRightContent(); indentedParentElement = nullptr; firstContentToBeOutdented = nullptr; lastContentToBeOutdented = nullptr; indentedParentIndentedWith = BlockIndentedWith::HTML; } nsresult rv = RemoveBlockContainerWithTransaction( MOZ_KnownLive(*content->AsElement())); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return SplitRangeOffFromNodeResult(rv); } continue; } // If we're using CSS and the node is a block element, check its start // margin whether it's indented with CSS. if (useCSS && HTMLEditUtils::IsBlockElement(content)) { nsStaticAtom& marginProperty = MarginPropertyAtomForIndent(MOZ_KnownLive(content)); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } nsAutoString value; DebugOnly rvIgnored = CSSEditUtils::GetSpecifiedProperty(content, marginProperty, value); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( NS_SUCCEEDED(rvIgnored), "CSSEditUtils::GetSpecifiedProperty() failed, but ignored"); float startMargin = 0; RefPtr unit; CSSEditUtils::ParseLength(value, &startMargin, getter_AddRefs(unit)); // If indented with CSS, we should decrease the start mergin. if (startMargin > 0) { nsresult rv = ChangeMarginStart(MOZ_KnownLive(*content->AsElement()), ChangeMargin::Decrease); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::ChangeMarginStart(ChangeMargin::" "Decrease) failed, but ignored"); continue; } } // If it's a list item, we should treat as that it "indents" its children. if (HTMLEditUtils::IsListItem(content)) { // If it is a list item, that means we are not outdenting whole list. // XXX I don't understand this sentence... We may meet parent list // element, no? if (indentedParentElement) { SplitRangeOffFromNodeResult outdentResult = OutdentPartOfBlock( *indentedParentElement, *firstContentToBeOutdented, *lastContentToBeOutdented, indentedParentIndentedWith); if (NS_WARN_IF(outdentResult.Failed())) { return outdentResult; } leftContentOfLastOutdented = outdentResult.GetLeftContent(); middleContentOfLastOutdented = outdentResult.GetMiddleContent(); rightContentOfLastOutdented = outdentResult.GetRightContent(); indentedParentElement = nullptr; firstContentToBeOutdented = nullptr; lastContentToBeOutdented = nullptr; indentedParentIndentedWith = BlockIndentedWith::HTML; } // XXX `content` could become different element since // `OutdentPartOfBlock()` may run mutation event listeners. rv = LiftUpListItemElement(MOZ_KnownLive(*content->AsElement()), LiftUpFromAllParentListElements::No); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::LiftUpListItemElement(LiftUpFromAllParentListElements:" ":No) failed"); return SplitRangeOffFromNodeResult(rv); } continue; } // If we've found an ancestor block element which indents its children // and the current node is NOT a descendant of it, we should remove it to // outdent its children. Otherwise, i.e., current node is a descendant of // it, we meet new node which should be outdented when the indented parent // is removed. if (indentedParentElement) { if (EditorUtils::IsDescendantOf(*content, *indentedParentElement)) { // Extend the range to be outdented at removing the // indentedParentElement. lastContentToBeOutdented = content; continue; } SplitRangeOffFromNodeResult outdentResult = OutdentPartOfBlock( *indentedParentElement, *firstContentToBeOutdented, *lastContentToBeOutdented, indentedParentIndentedWith); if (outdentResult.Failed()) { NS_WARNING("HTMLEditor::OutdentPartOfBlock() failed"); return outdentResult; } leftContentOfLastOutdented = outdentResult.GetLeftContent(); middleContentOfLastOutdented = outdentResult.GetMiddleContent(); rightContentOfLastOutdented = outdentResult.GetRightContent(); indentedParentElement = nullptr; firstContentToBeOutdented = nullptr; lastContentToBeOutdented = nullptr; // curBlockIndentedWith = HTMLEditor::BlockIndentedWith::HTML; // Then, we need to look for next indentedParentElement. } indentedParentIndentedWith = BlockIndentedWith::HTML; RefPtr editingHost = GetActiveEditingHost(); for (nsCOMPtr parentContent = content->GetParent(); parentContent && !parentContent->IsHTMLElement(nsGkAtoms::body) && parentContent != editingHost && (parentContent->IsHTMLElement(nsGkAtoms::table) || !HTMLEditUtils::IsAnyTableElement(parentContent)); parentContent = parentContent->GetParent()) { // If we reach a `
` ancestor, it should be split at next // time at least for outdenting current node. if (parentContent->IsHTMLElement(nsGkAtoms::blockquote)) { indentedParentElement = parentContent->AsElement(); firstContentToBeOutdented = content; lastContentToBeOutdented = content; break; } if (!useCSS) { continue; } nsCOMPtr grandParentNode = parentContent->GetParentNode(); nsStaticAtom& marginProperty = MarginPropertyAtomForIndent(MOZ_KnownLive(content)); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_WARN_IF(grandParentNode != parentContent->GetParentNode())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } nsAutoString value; DebugOnly rvIgnored = CSSEditUtils::GetSpecifiedProperty( *parentContent, marginProperty, value); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( NS_SUCCEEDED(rvIgnored), "CSSEditUtils::GetSpecifiedProperty() failed, but ignored"); // XXX Now, editing host may become different element. If so, shouldn't // we stop this handling? float startMargin; RefPtr unit; CSSEditUtils::ParseLength(value, &startMargin, getter_AddRefs(unit)); // If we reach a block element which indents its children with start // margin, we should remove it at next time. if (startMargin > 0 && !(HTMLEditUtils::IsAnyListElement(atContent.GetContainer()) && HTMLEditUtils::IsAnyListElement(content))) { indentedParentElement = parentContent->AsElement(); firstContentToBeOutdented = content; lastContentToBeOutdented = content; indentedParentIndentedWith = BlockIndentedWith::CSS; break; } } if (indentedParentElement) { continue; } // If we don't have any block elements which indents current node and // both current node and its parent are list element, remove current // node to move all its children to the parent list. // XXX This is buggy. When both lists' item types are different, // we create invalid tree. E.g., `
` may have `
` as its // list item element. if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { // Move node out of list if (HTMLEditUtils::IsAnyListElement(content)) { // Just unwrap this sublist nsresult rv = RemoveBlockContainerWithTransaction( MOZ_KnownLive(*content->AsElement())); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return SplitRangeOffFromNodeResult(rv); } } continue; } // If current content is a list element but its parent is not a list // element, move children to where it is and remove it from the tree. if (HTMLEditUtils::IsAnyListElement(content)) { // XXX If mutation event listener appends new children forever, this // becomes an infinite loop so that we should set limitation from // first child count. for (nsCOMPtr lastChildContent = content->GetLastChild(); lastChildContent; lastChildContent = content->GetLastChild()) { if (HTMLEditUtils::IsListItem(lastChildContent)) { nsresult rv = LiftUpListItemElement( MOZ_KnownLive(*lastChildContent->AsElement()), LiftUpFromAllParentListElements::No); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::LiftUpListItemElement(" "LiftUpFromAllParentListElements::No) failed"); return SplitRangeOffFromNodeResult(rv); } continue; } if (HTMLEditUtils::IsAnyListElement(lastChildContent)) { // We have an embedded list, so move it out from under the parent // list. Be sure to put it after the parent list because this // loop iterates backwards through the parent's list of children. EditorDOMPoint afterCurrentList(EditorDOMPoint::After(atContent)); NS_WARNING_ASSERTION( afterCurrentList.IsSet(), "Failed to set it to after current list element"); nsresult rv = MoveNodeWithTransaction(*lastChildContent, afterCurrentList); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); return SplitRangeOffFromNodeResult(rv); } continue; } // Delete any non-list items for now // XXX Chrome moves it from the list element. We should follow it. nsresult rv = DeleteNodeWithTransaction(*lastChildContent); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return SplitRangeOffFromNodeResult(rv); } } // Delete the now-empty list nsresult rv = RemoveBlockContainerWithTransaction( MOZ_KnownLive(*content->AsElement())); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return SplitRangeOffFromNodeResult(rv); } continue; } if (useCSS) { if (RefPtr element = content->GetAsElementOrParentElement()) { nsresult rv = ChangeMarginStart(*element, ChangeMargin::Decrease); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::ChangeMarginStart(ChangeMargin::" "Decrease) failed, but ignored"); } continue; } } if (!indentedParentElement) { return SplitRangeOffFromNodeResult(leftContentOfLastOutdented, middleContentOfLastOutdented, rightContentOfLastOutdented); } // We have a
we haven't finished handling. SplitRangeOffFromNodeResult outdentResult = OutdentPartOfBlock(*indentedParentElement, *firstContentToBeOutdented, *lastContentToBeOutdented, indentedParentIndentedWith); NS_WARNING_ASSERTION(outdentResult.Succeeded(), "HTMLEditor::OutdentPartOfBlock() failed"); return outdentResult; } SplitRangeOffFromNodeResult HTMLEditor::SplitRangeOffFromBlockAndRemoveMiddleContainer( Element& aBlockElement, nsIContent& aStartOfRange, nsIContent& aEndOfRange) { MOZ_ASSERT(IsEditActionDataAvailable()); SplitRangeOffFromNodeResult splitResult = SplitRangeOffFromBlock(aBlockElement, aStartOfRange, aEndOfRange); if (NS_WARN_IF(splitResult.Rv() == NS_ERROR_EDITOR_DESTROYED)) { return splitResult; } NS_WARNING_ASSERTION( splitResult.Succeeded(), "HTMLEditor::SplitRangeOffFromBlock() failed, but might be ignored"); nsresult rv = RemoveBlockContainerWithTransaction(aBlockElement); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return SplitRangeOffFromNodeResult(rv); } return SplitRangeOffFromNodeResult(splitResult.GetLeftContent(), nullptr, splitResult.GetRightContent()); } SplitRangeOffFromNodeResult HTMLEditor::SplitRangeOffFromBlock( Element& aBlockElement, nsIContent& aStartOfMiddleElement, nsIContent& aEndOfMiddleElement) { MOZ_ASSERT(IsEditActionDataAvailable()); // aStartOfMiddleElement and aEndOfMiddleElement must be exclusive // descendants of aBlockElement. MOZ_ASSERT(EditorUtils::IsDescendantOf(aStartOfMiddleElement, aBlockElement)); MOZ_ASSERT(EditorUtils::IsDescendantOf(aEndOfMiddleElement, aBlockElement)); // Split at the start. SplitNodeResult splitAtStartResult = SplitNodeDeepWithTransaction( aBlockElement, EditorDOMPoint(&aStartOfMiddleElement), SplitAtEdges::eDoNotCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(splitAtStartResult.Succeeded(), "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) failed"); // Split at after the end EditorDOMPoint atAfterEnd(&aEndOfMiddleElement); DebugOnly advanced = atAfterEnd.AdvanceOffset(); NS_WARNING_ASSERTION(advanced, "Failed to advance offset after the end node"); SplitNodeResult splitAtEndResult = SplitNodeDeepWithTransaction( aBlockElement, atAfterEnd, SplitAtEdges::eDoNotCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(splitAtEndResult.Succeeded(), "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) failed"); return SplitRangeOffFromNodeResult(splitAtStartResult, splitAtEndResult); } SplitRangeOffFromNodeResult HTMLEditor::OutdentPartOfBlock( Element& aBlockElement, nsIContent& aStartOfOutdent, nsIContent& aEndOfOutdent, BlockIndentedWith aBlockIndentedWith) { MOZ_ASSERT(IsEditActionDataAvailable()); SplitRangeOffFromNodeResult splitResult = SplitRangeOffFromBlock(aBlockElement, aStartOfOutdent, aEndOfOutdent); if (NS_WARN_IF(splitResult.EditorDestroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (!splitResult.GetMiddleContentAsElement()) { NS_WARNING( "HTMLEditor::SplitRangeOffFromBlock() didn't return middle content"); return SplitRangeOffFromNodeResult(NS_ERROR_FAILURE); } NS_WARNING_ASSERTION( splitResult.Succeeded(), "HTMLEditor::SplitRangeOffFromBlock() failed, but might be ignored"); if (aBlockIndentedWith == BlockIndentedWith::HTML) { nsresult rv = RemoveBlockContainerWithTransaction( MOZ_KnownLive(*splitResult.GetMiddleContentAsElement())); if (NS_WARN_IF(Destroyed())) { return SplitRangeOffFromNodeResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return SplitRangeOffFromNodeResult(rv); } return SplitRangeOffFromNodeResult(splitResult.GetLeftContent(), nullptr, splitResult.GetRightContent()); } if (splitResult.GetMiddleContentAsElement()) { nsresult rv = ChangeMarginStart( MOZ_KnownLive(*splitResult.GetMiddleContentAsElement()), ChangeMargin::Decrease); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::ChangeMarginStart(ChangeMargin::Decrease) failed"); return SplitRangeOffFromNodeResult(rv); } return splitResult; } return splitResult; } CreateElementResult HTMLEditor::ChangeListElementType(Element& aListElement, nsAtom& aNewListTag, nsAtom& aNewListItemTag) { MOZ_ASSERT(IsEditActionDataAvailable()); for (nsIContent* childContent = aListElement.GetFirstChild(); childContent; childContent = childContent->GetNextSibling()) { if (!childContent->IsElement()) { continue; } if (HTMLEditUtils::IsListItem(childContent->AsElement()) && !childContent->IsHTMLElement(&aNewListItemTag)) { OwningNonNull listItemElement = *childContent->AsElement(); RefPtr newListItemElement = ReplaceContainerWithTransaction(listItemElement, aNewListItemTag); if (NS_WARN_IF(Destroyed())) { return CreateElementResult(NS_ERROR_EDITOR_DESTROYED); } if (!newListItemElement) { NS_WARNING("HTMLEditor::ReplaceContainerWithTransaction() failed"); return CreateElementResult(NS_ERROR_FAILURE); } childContent = newListItemElement; continue; } if (HTMLEditUtils::IsAnyListElement(childContent->AsElement()) && !childContent->IsHTMLElement(&aNewListTag)) { // XXX List elements shouldn't have other list elements as their // child. Why do we handle such invalid tree? // -> Maybe, for bug 525888. OwningNonNull listElement = *childContent->AsElement(); CreateElementResult convertListTypeResult = ChangeListElementType(listElement, aNewListTag, aNewListItemTag); if (convertListTypeResult.Failed()) { NS_WARNING("HTMLEditor::ChangeListElementType() failed"); return convertListTypeResult; } childContent = convertListTypeResult.GetNewNode(); continue; } } if (aListElement.IsHTMLElement(&aNewListTag)) { return CreateElementResult(&aListElement); } RefPtr listElement = ReplaceContainerWithTransaction(aListElement, aNewListTag); if (NS_WARN_IF(Destroyed())) { return CreateElementResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(listElement, "HTMLEditor::ReplaceContainerWithTransaction() failed"); return CreateElementResult(std::move(listElement)); } nsresult HTMLEditor::CreateStyleForInsertText( const AbstractRange& aAbstractRange) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aAbstractRange.IsPositioned()); MOZ_ASSERT(mTypeInState); RefPtr documentRootElement = GetDocument()->GetRootElement(); if (NS_WARN_IF(!documentRootElement)) { return NS_ERROR_FAILURE; } // process clearing any styles first UniquePtr item = mTypeInState->TakeClearProperty(); EditorDOMPoint pointToPutCaret(aAbstractRange.StartRef()); bool putCaret = false; { // Transactions may set selection, but we will set selection if necessary. AutoTransactionsConserveSelection dontChangeMySelection(*this); while (item && pointToPutCaret.GetContainer() != documentRootElement) { EditResult result = ClearStyleAt( pointToPutCaret, MOZ_KnownLive(item->tag), MOZ_KnownLive(item->attr)); if (result.Failed()) { NS_WARNING("HTMLEditor::ClearStyleAt() failed"); return result.Rv(); } pointToPutCaret = result.PointRefToCollapseSelection(); item = mTypeInState->TakeClearProperty(); putCaret = true; } } // then process setting any styles int32_t relFontSize = mTypeInState->TakeRelativeFontSize(); item = mTypeInState->TakeSetProperty(); if (item || relFontSize) { // we have at least one style to add; make a new text node to insert style // nodes above. if (pointToPutCaret.IsInTextNode()) { // if we are in a text node, split it SplitNodeResult splitTextNodeResult = SplitNodeDeepWithTransaction( MOZ_KnownLive(*pointToPutCaret.GetContainerAsText()), pointToPutCaret, SplitAtEdges::eAllowToCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (splitTextNodeResult.Failed()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eAllowToCreateEmptyContainer) failed"); return splitTextNodeResult.Rv(); } pointToPutCaret = splitTextNodeResult.SplitPoint(); } if (!pointToPutCaret.IsInContentNode() || !HTMLEditUtils::IsContainerNode( *pointToPutCaret.ContainerAsContent())) { return NS_OK; } RefPtr newEmptyTextNode = CreateTextNode(u""_ns); if (!newEmptyTextNode) { NS_WARNING("EditorBase::CreateTextNode() failed"); return NS_ERROR_FAILURE; } nsresult rv = InsertNodeWithTransaction(*newEmptyTextNode, pointToPutCaret); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("EditorBase::InsertNodeWithTransaction() failed"); return rv; } pointToPutCaret.Set(newEmptyTextNode, 0); putCaret = true; if (relFontSize) { // dir indicated bigger versus smaller. 1 = bigger, -1 = smaller HTMLEditor::FontSize dir = relFontSize > 0 ? HTMLEditor::FontSize::incr : HTMLEditor::FontSize::decr; for (int32_t j = 0; j < DeprecatedAbs(relFontSize); j++) { nsresult rv = RelativeFontChangeOnTextNode(dir, *newEmptyTextNode, 0, -1); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RelativeFontChangeOnTextNode() failed"); return rv; } } } while (item) { nsresult rv = SetInlinePropertyOnNode( MOZ_KnownLive(*pointToPutCaret.GetContainerAsContent()), MOZ_KnownLive(*item->tag), MOZ_KnownLive(item->attr), item->value); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::SetInlinePropertyOnNode() failed"); return rv; } item = mTypeInState->TakeSetProperty(); } } if (!putCaret) { return NS_OK; } nsresult rv = CollapseSelectionTo(pointToPutCaret); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } bool HTMLEditor::IsEmptyBlockElement(Element& aElement, IgnoreSingleBR aIgnoreSingleBR) const { if (!HTMLEditUtils::IsBlockElement(aElement)) { return false; } return IsEmptyNode(aElement, aIgnoreSingleBR == IgnoreSingleBR::Yes); } EditActionResult HTMLEditor::AlignAsSubAction(const nsAString& aAlignType) { MOZ_ASSERT(IsEditActionDataAvailable()); AutoPlaceholderBatch treatAsOneTransaction(*this, ScrollSelectionIntoView::Yes); IgnoredErrorResult ignoredError; AutoEditSubActionNotifier startToHandleEditSubAction( *this, EditSubAction::eSetOrClearAlignment, nsIEditor::eNext, ignoredError); if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { return EditActionResult(ignoredError.StealNSResult()); } NS_WARNING_ASSERTION( !ignoredError.Failed(), "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); EditActionResult result = CanHandleHTMLEditSubAction(); if (result.Failed() || result.Canceled()) { NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::CanHandleHTMLEditSubAction() failed"); return result; } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Some selection containers are not content node, but ignored"); return EditActionIgnored(); } nsresult rv = EnsureNoPaddingBRElementForEmptyEditor(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() " "failed, but ignored"); if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Mutation event listener might have changed the selection"); return EditActionHandled(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } if (NS_SUCCEEDED(rv) && SelectionRefPtr()->IsCollapsed()) { nsresult rv = EnsureCaretNotAfterPaddingBRElement(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::EnsureCaretNotAfterPaddingBRElement() " "failed, but ignored"); if (NS_SUCCEEDED(rv)) { nsresult rv = PrepareInlineStylesForCaret(); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored"); } } if (!SelectionRefPtr()->IsCollapsed()) { nsresult rv = MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::MaybeExtendSelectionToHardLineEdgesForBlockEditAction() " "failed"); return EditActionResult(rv); } } // AlignContentsAtSelection() creates AutoSelectionRestorer. Therefore, // we need to check whether we've been destroyed or not even if it returns // NS_OK. rv = AlignContentsAtSelection(aAlignType); if (NS_WARN_IF(Destroyed())) { return EditActionHandled(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::AlignContentsAtSelection() failed"); return EditActionHandled(rv); } if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Mutation event listener might have changed the selection"); return EditActionHandled(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); } rv = MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() " "failed"); return EditActionHandled(rv); } nsresult HTMLEditor::AlignContentsAtSelection(const nsAString& aAlignType) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); AutoSelectionRestorer restoreSelectionLater(*this); // Convert the selection ranges into "promoted" selection ranges: This // basically just expands the range to include the immediate block parent, // and then further expands to include any ancestors whose children are all // in the range AutoTArray, 64> arrayOfContents; nsresult rv = SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges( arrayOfContents, EditSubAction::eSetOrClearAlignment, CollectNonEditableNodes::Yes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::" "SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges(" "eSetOrClearAlignment, CollectNonEditableNodes::Yes) failed"); return rv; } // If we don't have any nodes, or we have only a single br, then we are // creating an empty alignment div. We have to do some different things for // these. bool createEmptyDivElement = arrayOfContents.IsEmpty(); if (arrayOfContents.Length() == 1) { OwningNonNull& content = arrayOfContents[0]; if (HTMLEditUtils::SupportsAlignAttr(content)) { // The node is a table element, an hr, a paragraph, a div or a section // header; in HTML 4, it can directly carry the ALIGN attribute and we // don't need to make a div! If we are in CSS mode, all the work is done // in SetBlockElementAlign(). nsresult rv = SetBlockElementAlign(MOZ_KnownLive(*content->AsElement()), aAlignType, EditTarget::OnlyDescendantsExceptTable); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::SetBlockElementAlign() failed"); return rv; } if (content->IsHTMLElement(nsGkAtoms::br)) { // The special case createEmptyDivElement code (below) that consumes // `
` elements can cause tables to split if the start node of the // selection is not in a table cell or caption, for example parent is a // ``. Avoid this unnecessary splitting if possible by leaving // createEmptyDivElement false so that we fall through to the normal case // alignment code. // // XXX: It seems a little error prone for the createEmptyDivElement // special case code to assume that the start node of the selection // is the parent of the single node in the arrayOfContents, as the // paragraph above points out. Do we rely on the selection start // node because of the fact that arrayOfContents can be empty? We // should probably revisit this issue. - kin const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return NS_ERROR_FAILURE; } const RangeBoundary& atStartOfSelection = firstRange->StartRef(); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return NS_ERROR_FAILURE; } nsINode* parent = atStartOfSelection.Container(); createEmptyDivElement = !HTMLEditUtils::IsAnyTableElement(parent) || HTMLEditUtils::IsTableCellOrCaption(*parent); } } if (createEmptyDivElement) { if (IsSelectionRangeContainerNotContent()) { NS_WARNING("Mutaiton event listener might have changed the selection"); return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } EditActionResult result = AlignContentsAtSelectionWithEmptyDivElement(aAlignType); NS_WARNING_ASSERTION( result.Succeeded(), "HTMLEditor::AlignContentsAtSelectionWithEmptyDivElement() failed"); if (result.Handled()) { restoreSelectionLater.Abort(); } return rv; } rv = AlignNodesAndDescendants(arrayOfContents, aAlignType); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::AlignNodesAndDescendants() failed"); return rv; } EditActionResult HTMLEditor::AlignContentsAtSelectionWithEmptyDivElement( const nsAString& aAlignType) { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return EditActionResult(NS_ERROR_FAILURE); } EditorDOMPoint atStartOfSelection(firstRange->StartRef()); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return EditActionResult(NS_ERROR_FAILURE); } SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction( *nsGkAtoms::div, atStartOfSelection); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction(nsGkAtoms::" "div) failed"); return EditActionResult(splitNodeResult.Rv()); } EditorDOMPoint pointToInsertDiv(splitNodeResult.SplitPoint()); // Consume a trailing br, if any. This is to keep an alignment from // creating extra lines, if possible. if (nsCOMPtr maybeBRContent = GetNextEditableHTMLNodeInBlock(splitNodeResult.SplitPoint())) { if (maybeBRContent->IsHTMLElement(nsGkAtoms::br) && pointToInsertDiv.GetChild()) { // Making use of html structure... if next node after where we are // putting our div is not a block, then the br we found is in same block // we are, so it's safe to consume it. if (nsIContent* nextEditableSibling = GetNextHTMLSibling(pointToInsertDiv.GetChild())) { if (!HTMLEditUtils::IsBlockElement(*nextEditableSibling)) { AutoEditorDOMPointChildInvalidator lockOffset(pointToInsertDiv); nsresult rv = DeleteNodeWithTransaction(*maybeBRContent); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return EditActionResult(rv); } } } } } RefPtr divElement = CreateNodeWithTransaction(*nsGkAtoms::div, pointToInsertDiv); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } if (!divElement) { NS_WARNING("EditorBase::CreateNodeWithTransaction(nsGkAtoms::div) failed"); return EditActionResult(NS_ERROR_FAILURE); } // Remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = divElement; // Set up the alignment on the div, using HTML or CSS nsresult rv = SetBlockElementAlign(*divElement, aAlignType, EditTarget::OnlyDescendantsExceptTable); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::SetBlockElementAlign(EditTarget::" "OnlyDescendantsExceptTable) failed"); return EditActionResult(rv); } // Put in a padding
element for empty last line so that it won't get // deleted. CreateElementResult createPaddingBRResult = InsertPaddingBRElementForEmptyLastLineWithTransaction( EditorDOMPoint(divElement, 0)); if (createPaddingBRResult.Failed()) { NS_WARNING( "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction() " "failed"); return EditActionResult(createPaddingBRResult.Rv()); } rv = CollapseSelectionToStartOf(*divElement); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return EditActionHandled(rv); } nsresult HTMLEditor::AlignNodesAndDescendants( nsTArray>& aArrayOfContents, const nsAString& aAlignType) { // Detect all the transitions in the array, where a transition means that // adjacent nodes in the array don't have the same parent. AutoTArray transitionList; HTMLEditor::MakeTransitionList(aArrayOfContents, transitionList); // Okay, now go through all the nodes and give them an align attrib or put // them in a div, or whatever is appropriate. Woohoo! RefPtr createdDivElement; bool useCSS = IsCSSEnabled(); int32_t indexOfTransitionList = -1; for (OwningNonNull& content : aArrayOfContents) { ++indexOfTransitionList; // Ignore all non-editable nodes. Leave them be. if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { continue; } // The node is a table element, an hr, a paragraph, a div or a section // header; in HTML 4, it can directly carry the ALIGN attribute and we // don't need to nest it, just set the alignment. In CSS, assign the // corresponding CSS styles in SetBlockElementAlign(). if (HTMLEditUtils::SupportsAlignAttr(content)) { nsresult rv = SetBlockElementAlign(MOZ_KnownLive(*content->AsElement()), aAlignType, EditTarget::NodeAndDescendantsExceptTable); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::SetBlockElementAlign(EditTarget::" "NodeAndDescendantsExceptTable) failed"); return rv; } // Clear out createdDivElement so that we don't put nodes after this one // into it createdDivElement = nullptr; continue; } EditorDOMPoint atContent(content); if (NS_WARN_IF(!atContent.IsSet())) { continue; } // Skip insignificant formatting text nodes to prevent unnecessary // structure splitting! if (content->IsText() && ((HTMLEditUtils::IsAnyTableElement(atContent.GetContainer()) && !HTMLEditUtils::IsTableCellOrCaption(*atContent.GetContainer())) || HTMLEditUtils::IsAnyListElement(atContent.GetContainer()) || IsEmptyNode(*content))) { continue; } // If it's a list item, or a list inside a list, forget any "current" div, // and instead put divs inside the appropriate block (td, li, etc.) if (HTMLEditUtils::IsListItem(content) || HTMLEditUtils::IsAnyListElement(content)) { Element* listOrListItemElement = content->AsElement(); AutoEditorDOMPointOffsetInvalidator lockChild(atContent); // MOZ_KnownLive(*listOrListItemElement): An element of aArrayOfContents // which is array of OwningNonNull. nsresult rv = RemoveAlignFromDescendants( MOZ_KnownLive(*listOrListItemElement), aAlignType, EditTarget::OnlyDescendantsExceptTable); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::RemoveAlignFromDescendants(EditTarget::" "OnlyDescendantsExceptTable) failed"); return rv; } if (useCSS) { if (nsStyledElement* styledListOrListItemElement = nsStyledElement::FromNode(listOrListItemElement)) { // MOZ_KnownLive(*styledListOrListItemElement): An element of // aArrayOfContents which is array of OwningNonNull. Result result = mCSSEditUtils->SetCSSEquivalentToHTMLStyleWithTransaction( MOZ_KnownLive(*styledListOrListItemElement), nullptr, nsGkAtoms::align, &aAlignType); if (result.isErr()) { if (result.inspectErr() == NS_ERROR_EDITOR_DESTROYED) { NS_WARNING( "CSSEditUtils::SetCSSEquivalentToHTMLStyleWithTransaction(" "nsGkAtoms::align) destroyed the editor"); return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING( "CSSEditUtils::SetCSSEquivalentToHTMLStyleWithTransaction(" "nsGkAtoms::align) failed, but ignored"); } } createdDivElement = nullptr; continue; } if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { // If we don't use CSS, add a content to list element: they have to // be inside another list, i.e., >= second level of nesting. // XXX AlignContentsInAllTableCellsAndListItems() handles only list // item elements and table cells. Is it intentional? Why don't // we need to align contents in other type blocks? // MOZ_KnownLive(*listOrListItemElement): An element of aArrayOfContents // which is array of OwningNonNull. nsresult rv = AlignContentsInAllTableCellsAndListItems( MOZ_KnownLive(*listOrListItemElement), aAlignType); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::AlignContentsInAllTableCellsAndListItems() failed"); return rv; } createdDivElement = nullptr; continue; } // Clear out createdDivElement so that we don't put nodes after this one // into it } // Need to make a div to put things in if we haven't already, or if this // node doesn't go in div we used earlier. if (!createdDivElement || transitionList[indexOfTransitionList]) { // First, check that our element can contain a div. if (!HTMLEditUtils::CanNodeContain(*atContent.GetContainer(), *nsGkAtoms::div)) { // XXX Why do we return NS_OK here rather than returning error or // doing continue? return NS_OK; } SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(*nsGkAtoms::div, atContent); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction(nsGkAtoms:" ":div) failed"); return splitNodeResult.Rv(); } createdDivElement = CreateNodeWithTransaction( *nsGkAtoms::div, splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!createdDivElement) { NS_WARNING( "EditorBase::CreateNodeWithTransaction(nsGkAtoms::div) failed"); return NS_ERROR_FAILURE; } // Remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = createdDivElement; // Set up the alignment on the div nsresult rv = SetBlockElementAlign(*createdDivElement, aAlignType, EditTarget::OnlyDescendantsExceptTable); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::SetBlockElementAlign(EditTarget::" "OnlyDescendantsExceptTable) failed, but ignored"); } // Tuck the node into the end of the active div // // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it alive. nsresult rv = MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *createdDivElement); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } } return NS_OK; } nsresult HTMLEditor::AlignContentsInAllTableCellsAndListItems( Element& aElement, const nsAString& aAlignType) { MOZ_ASSERT(IsEditActionDataAvailable()); // Gather list of table cells or list items AutoTArray, 64> arrayOfTableCellsAndListItems; DOMIterator iter(aElement); iter.AppendNodesToArray( +[](nsINode& aNode, void*) -> bool { MOZ_ASSERT(Element::FromNode(&aNode)); return HTMLEditUtils::IsTableCell(&aNode) || HTMLEditUtils::IsListItem(&aNode); }, arrayOfTableCellsAndListItems); // Now that we have the list, align their contents as requested for (auto& tableCellOrListItemElement : arrayOfTableCellsAndListItems) { // MOZ_KnownLive because 'arrayOfTableCellsAndListItems' is guaranteed to // keep it alive. nsresult rv = AlignBlockContentsWithDivElement( MOZ_KnownLive(tableCellOrListItemElement), aAlignType); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::AlignBlockContentsWithDivElement() failed"); return rv; } } return NS_OK; } nsresult HTMLEditor::AlignBlockContentsWithDivElement( Element& aBlockElement, const nsAString& aAlignType) { MOZ_ASSERT(IsEditActionDataAvailable()); // XXX I don't understand why we should NOT align non-editable children // with modifying EDITABLE `
` element. nsCOMPtr firstEditableContent = GetFirstEditableChild(aBlockElement); if (!firstEditableContent) { // This block has no editable content, nothing to align. return NS_OK; } // If there is only one editable content and it's a `
` element, // just set `align` attribute of it. nsCOMPtr lastEditableContent = GetLastEditableChild(aBlockElement); if (firstEditableContent == lastEditableContent && firstEditableContent->IsHTMLElement(nsGkAtoms::div)) { nsresult rv = SetAttributeOrEquivalent( MOZ_KnownLive(firstEditableContent->AsElement()), nsGkAtoms::align, aAlignType, false); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "EditorBase::SetAttributeOrEquivalent(nsGkAtoms::align) failed"); return rv; } // Otherwise, we need to insert a `
` element to set `align` attribute. // XXX Don't insert the new `
` element until we set `align` attribute // for avoiding running mutation event listeners. RefPtr divElement = CreateNodeWithTransaction( *nsGkAtoms::div, EditorDOMPoint(&aBlockElement, 0)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!divElement) { NS_WARNING("EditorBase::CreateNodeWithTransaction(nsGkAtoms::div) failed"); return NS_ERROR_FAILURE; } nsresult rv = SetAttributeOrEquivalent(divElement, nsGkAtoms::align, aAlignType, false); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("EditorBase::SetAttributeOrEquivalent(nsGkAtoms::align) failed"); return rv; } // XXX This is tricky and does not work with mutation event listeners. // But I'm not sure what we should do if new content is inserted. // Anyway, I don't think that we should move editable contents // over non-editable contents. Chrome does no do that. while (lastEditableContent && (lastEditableContent != divElement)) { nsresult rv = MoveNodeWithTransaction(*lastEditableContent, EditorDOMPoint(divElement, 0)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); return rv; } lastEditableContent = GetLastEditableChild(aBlockElement); } return NS_OK; } size_t HTMLEditor::CollectChildren( nsINode& aNode, nsTArray>& aOutArrayOfContents, size_t aIndexToInsertChildren, CollectListChildren aCollectListChildren, CollectTableChildren aCollectTableChildren, CollectNonEditableNodes aCollectNonEditableNodes) const { MOZ_ASSERT(IsEditActionDataAvailable()); size_t numberOfFoundChildren = 0; for (nsIContent* content = GetFirstEditableChild(aNode); content; content = content->GetNextSibling()) { if ((aCollectListChildren == CollectListChildren::Yes && (HTMLEditUtils::IsAnyListElement(content) || HTMLEditUtils::IsListItem(content))) || (aCollectTableChildren == CollectTableChildren::Yes && HTMLEditUtils::IsAnyTableElement(content))) { numberOfFoundChildren += CollectChildren( *content, aOutArrayOfContents, aIndexToInsertChildren + numberOfFoundChildren, aCollectListChildren, aCollectTableChildren, aCollectNonEditableNodes); } else if (aCollectNonEditableNodes == CollectNonEditableNodes::Yes || EditorUtils::IsEditableContent(*content, EditorType::HTML)) { aOutArrayOfContents.InsertElementAt( aIndexToInsertChildren + numberOfFoundChildren++, *content); } } return numberOfFoundChildren; } nsresult HTMLEditor::MaybeExtendSelectionToHardLineEdgesForBlockEditAction() { MOZ_ASSERT(IsEditActionDataAvailable()); // This tweaks selections to be more "natural". // Idea here is to adjust edges of selection ranges so that they do not cross // breaks or block boundaries unless something editable beyond that boundary // is also selected. This adjustment makes it much easier for the various // block operations to determine what nodes to act on. // We don't need to mess with cell selections, and we assume multirange // selections are those. // XXX Why? Even in , user can select 2 or more ranges. if (SelectionRefPtr()->RangeCount() != 1) { return NS_OK; } const RefPtr range = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!range)) { return NS_ERROR_FAILURE; } if (NS_WARN_IF(!range->IsPositioned())) { return NS_ERROR_FAILURE; } const EditorDOMPoint startPoint(range->StartRef()); if (NS_WARN_IF(!startPoint.IsSet())) { return NS_ERROR_FAILURE; } const EditorDOMPoint endPoint(range->EndRef()); if (NS_WARN_IF(!endPoint.IsSet())) { return NS_ERROR_FAILURE; } // adjusted values default to original values EditorDOMPoint newStartPoint(startPoint); EditorDOMPoint newEndPoint(endPoint); // Is there any intervening visible white-space? If so we can't push // selection past that, it would visibly change meaning of users selection. WSRunScanner wsScannerAtEnd(*this, endPoint); WSScanResult scanResultAtEnd = wsScannerAtEnd.ScanPreviousVisibleNodeOrBlockBoundaryFrom(endPoint); if (scanResultAtEnd.Failed()) { NS_WARNING( "WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundaryFrom() failed"); return NS_ERROR_FAILURE; } if (scanResultAtEnd.ReachedSomething()) { // eThisBlock and eOtherBlock conveniently distinguish cases // of going "down" into a block and "up" out of a block. if (wsScannerAtEnd.StartsFromOtherBlockElement()) { // endpoint is just after the close of a block. nsIContent* child = HTMLEditUtils::GetLastLeafChild( *wsScannerAtEnd.StartReasonOtherBlockElementPtr(), ChildBlockBoundary::TreatAsLeaf); if (child) { newEndPoint.SetAfter(child); } // else block is empty - we can leave selection alone here, i think. } else if (wsScannerAtEnd.StartsFromCurrentBlockBoundary()) { // endpoint is just after start of this block nsINode* child = GetPreviousEditableHTMLNode(endPoint); if (child) { newEndPoint.SetAfter(child); } // else block is empty - we can leave selection alone here, i think. } else if (wsScannerAtEnd.StartsFromBRElement()) { // endpoint is just after break. lets adjust it to before it. newEndPoint.Set(wsScannerAtEnd.StartReasonBRElementPtr()); } } // Is there any intervening visible white-space? If so we can't push // selection past that, it would visibly change meaning of users selection. WSRunScanner wsScannerAtStart(*this, startPoint); WSScanResult scanResultAtStart = wsScannerAtStart.ScanNextVisibleNodeOrBlockBoundaryFrom(startPoint); if (scanResultAtStart.Failed()) { NS_WARNING("WSRunScanner::ScanNextVisibleNodeOrBlockBoundaryFrom() failed"); return NS_ERROR_FAILURE; } if (scanResultAtStart.ReachedSomething()) { // eThisBlock and eOtherBlock conveniently distinguish cases // of going "down" into a block and "up" out of a block. if (wsScannerAtStart.EndsByOtherBlockElement()) { // startpoint is just before the start of a block. nsINode* child = HTMLEditUtils::GetFirstLeafChild( *wsScannerAtStart.EndReasonOtherBlockElementPtr(), ChildBlockBoundary::TreatAsLeaf); if (child) { newStartPoint.Set(child); } // else block is empty - we can leave selection alone here, i think. } else if (wsScannerAtStart.EndsByCurrentBlockBoundary()) { // startpoint is just before end of this block nsINode* child = GetNextEditableHTMLNode(startPoint); if (child) { newStartPoint.Set(child); } // else block is empty - we can leave selection alone here, i think. } else if (wsScannerAtStart.EndsByBRElement()) { // startpoint is just before a break. lets adjust it to after it. newStartPoint.SetAfter(wsScannerAtStart.EndReasonBRElementPtr()); } } // There is a demented possibility we have to check for. We might have a very // strange selection that is not collapsed and yet does not contain any // editable content, and satisfies some of the above conditions that cause // tweaking. In this case we don't want to tweak the selection into a block // it was never in, etc. There are a variety of strategies one might use to // try to detect these cases, but I think the most straightforward is to see // if the adjusted locations "cross" the old values: i.e., new end before old // start, or new start after old end. If so then just leave things alone. Maybe comp = nsContentUtils::ComparePoints( startPoint.ToRawRangeBoundary(), newEndPoint.ToRawRangeBoundary()); if (NS_WARN_IF(!comp)) { return NS_ERROR_FAILURE; } if (*comp == 1) { return NS_OK; // New end before old start. } comp = nsContentUtils::ComparePoints(newStartPoint.ToRawRangeBoundary(), endPoint.ToRawRangeBoundary()); if (NS_WARN_IF(!comp)) { return NS_ERROR_FAILURE; } if (*comp == 1) { return NS_OK; // New start after old end. } // Otherwise set selection to new values. Note that end point may be prior // to start point. So, we cannot use Selection::SetStartAndEndInLimit() here. ErrorResult error; MOZ_KnownLive(SelectionRefPtr()) ->SetBaseAndExtentInLimiter(newStartPoint, newEndPoint, error); if (NS_WARN_IF(Destroyed())) { error = NS_ERROR_EDITOR_DESTROYED; } else if (error.Failed()) { NS_WARNING("Selection::SetBaseAndExtentInLimiter() failed"); } return error.StealNSResult(); } // static template EditorDOMPoint HTMLEditor::GetWhiteSpaceEndPoint( const RangeBoundaryBase& aPoint, ScanDirection aScanDirection) { if (NS_WARN_IF(!aPoint.IsSet()) || NS_WARN_IF(!aPoint.Container()->IsContent())) { return EditorDOMPoint(); } bool isSpace = false, isNBSP = false; nsIContent* newContent = aPoint.Container()->AsContent(); int32_t newOffset = *aPoint.Offset( RangeBoundaryBase::OffsetFilter::kValidOrInvalidOffsets); while (newContent) { int32_t offset = -1; nsCOMPtr content; if (aScanDirection == ScanDirection::Backward) { HTMLEditor::IsPrevCharInNodeWhiteSpace(newContent, newOffset, &isSpace, &isNBSP, getter_AddRefs(content), &offset); } else { HTMLEditor::IsNextCharInNodeWhiteSpace(newContent, newOffset, &isSpace, &isNBSP, getter_AddRefs(content), &offset); } if (!isSpace && !isNBSP) { break; } newContent = content; newOffset = offset; } return EditorDOMPoint(newContent, newOffset); } template EditorDOMPoint HTMLEditor::GetCurrentHardLineStartPoint( const RangeBoundaryBase& aPoint, EditSubAction aEditSubAction) const { if (NS_WARN_IF(!aPoint.IsSet())) { return EditorDOMPoint(); } EditorDOMPoint point(aPoint); // Start scanning from the container node if aPoint is in a text node. // XXX Perhaps, IsInDataNode() must be expected. if (point.IsInTextNode()) { if (!point.GetContainer()->GetParentNode()) { // Okay, can't promote any further // XXX Why don't we return start of the text node? return point; } point.Set(point.GetContainer()); } // Look back through any further inline nodes that aren't across a
// from us, and that are enclosed in the same block. // I.e., looking for start of current hard line. for (nsIContent* previousEditableContent = GetPreviousEditableHTMLNodeInBlock(point); previousEditableContent && previousEditableContent->GetParentNode() && !IsVisibleBRElement(previousEditableContent) && !HTMLEditUtils::IsBlockElement(*previousEditableContent); previousEditableContent = GetPreviousEditableHTMLNodeInBlock(point)) { point.Set(previousEditableContent); // XXX Why don't we check \n in pre-formated text node here? } // Finding the real start for this point unless current line starts after //
element. Look up the tree for as long as we are the first node in // the container (typically, start of nearest block ancestor), and as long // as we haven't hit the body node. for (nsIContent* nearContent = GetPreviousEditableHTMLNodeInBlock(point); !nearContent && !point.IsContainerHTMLElement(nsGkAtoms::body) && point.GetContainer()->GetParentNode(); nearContent = GetPreviousEditableHTMLNodeInBlock(point)) { // Don't keep looking up if we have found a blockquote element to act on // when we handle outdent. // XXX Sounds like this is hacky. If possible, it should be check in // outdent handler for consistency between edit sub-actions. // We should check Chromium's behavior of outdent when Selection // starts from `
` and starts from first child of // `
`. if (aEditSubAction == EditSubAction::eOutdent && point.IsContainerHTMLElement(nsGkAtoms::blockquote)) { break; } // 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 if we're not performing a block-level action. // XXX Here is too slow. Let's cache active editing host first, then, // compair with container of the point when we climb up the tree. bool blockLevelAction = aEditSubAction == EditSubAction::eIndent || aEditSubAction == EditSubAction::eOutdent || aEditSubAction == EditSubAction::eSetOrClearAlignment || aEditSubAction == EditSubAction::eCreateOrRemoveBlock; if (!IsDescendantOfEditorRoot(point.GetContainer()->GetParentNode()) && (blockLevelAction || !IsDescendantOfEditorRoot(point.GetContainer()))) { break; } point.Set(point.GetContainer()); } return point; } template EditorDOMPoint HTMLEditor::GetCurrentHardLineEndPoint( const RangeBoundaryBase& aPoint) const { if (NS_WARN_IF(!aPoint.IsSet())) { return EditorDOMPoint(); } EditorDOMPoint point(aPoint); // Start scanning from the container node if aPoint is in a text node. // XXX Perhaps, IsInDataNode() must be expected. if (point.IsInTextNode()) { if (!point.GetContainer()->GetParentNode()) { // Okay, can't promote any further // XXX Why don't we return end of the text node? return point; } // want to be after the text node point.SetAfter(point.GetContainer()); NS_WARNING_ASSERTION(point.IsSet(), "Failed to set to after the text node"); } // Look ahead through any further inline nodes that aren't across a
from // us, and that are enclosed in the same block. // XXX Currently, we stop block-extending when finding visible
element. // This might be different from "block-extend" of execCommand spec. // However, the spec is really unclear. // XXX Probably, scanning only editable nodes is wrong for // EditSubAction::eCreateOrRemoveBlock because it might be better to wrap // existing inline elements even if it's non-editable. For example, // following examples with insertParagraph causes different result: // *
foo[]bar
// *
foo[]bar
// *
foo[]barbaz
// Only in the first case, after the caret position isn't wrapped with // new
element. for (nsIContent* nextEditableContent = GetNextEditableHTMLNodeInBlock(point); nextEditableContent && !HTMLEditUtils::IsBlockElement(*nextEditableContent) && nextEditableContent->GetParent(); nextEditableContent = GetNextEditableHTMLNodeInBlock(point)) { point.SetAfter(nextEditableContent); if (NS_WARN_IF(!point.IsSet())) { break; } if (IsVisibleBRElement(nextEditableContent)) { break; } // Check for newlines in pre-formatted text nodes. if (nextEditableContent->IsText() && EditorUtils::IsContentPreformatted(*nextEditableContent)) { nsAutoString textContent; nextEditableContent->GetAsText()->GetData(textContent); int32_t newlinePos = textContent.FindChar(nsCRT::LF); if (newlinePos >= 0) { if (static_cast(newlinePos) + 1 == textContent.Length()) { // No need for special processing if the newline is at the end. break; } return EditorDOMPoint(nextEditableContent, newlinePos + 1); } } } // 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 = GetNextEditableHTMLNodeInBlock(point); !nearContent && !point.IsContainerHTMLElement(nsGkAtoms::body) && point.GetContainer()->GetParentNode(); nearContent = GetNextEditableHTMLNodeInBlock(point)) { // 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. // XXX Here is too slow. Let's cache active editing host first, then, // compair with container of the point when we climb up the tree. if (!IsDescendantOfEditorRoot(point.GetContainer()) && !IsDescendantOfEditorRoot(point.GetContainer()->GetParentNode())) { break; } point.SetAfter(point.GetContainer()); if (NS_WARN_IF(!point.IsSet())) { break; } } return point; } void HTMLEditor::GetSelectionRangesExtendedToIncludeAdjuscentWhiteSpaces( nsTArray>& aOutArrayOfRanges) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aOutArrayOfRanges.IsEmpty()); aOutArrayOfRanges.SetCapacity(SelectionRefPtr()->RangeCount()); for (uint32_t i = 0; i < SelectionRefPtr()->RangeCount(); i++) { const nsRange* selectionRange = SelectionRefPtr()->GetRangeAt(i); MOZ_ASSERT(selectionRange); RefPtr extendedRange = CreateRangeIncludingAdjuscentWhiteSpaces(*selectionRange); if (!extendedRange) { extendedRange = selectionRange->CloneRange(); } aOutArrayOfRanges.AppendElement(extendedRange); } } void HTMLEditor::GetSelectionRangesExtendedToHardLineStartAndEnd( nsTArray>& aOutArrayOfRanges, EditSubAction aEditSubAction) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aOutArrayOfRanges.IsEmpty()); aOutArrayOfRanges.SetCapacity(SelectionRefPtr()->RangeCount()); for (uint32_t i = 0; i < SelectionRefPtr()->RangeCount(); i++) { // Make a new adjusted range to represent the appropriate block content. // The basic idea is to push out the range endpoints to truly enclose the // blocks that we will affect. This call alters opRange. nsRange* selectionRange = SelectionRefPtr()->GetRangeAt(i); MOZ_ASSERT(selectionRange); RefPtr extendedRange = CreateRangeExtendedToHardLineStartAndEnd( *selectionRange, aEditSubAction); if (!extendedRange) { extendedRange = selectionRange->CloneRange(); } aOutArrayOfRanges.AppendElement(extendedRange); } } template void HTMLEditor::SelectBRElementIfCollapsedInEmptyBlock( RangeBoundaryBase& aStartRef, RangeBoundaryBase& aEndRef) const { // MOOSE major hack: // The GetWhiteSpaceEndPoint(), GetCurrentHardLineStartPoint() and // GetCurrentHardLineEndPoint() don't really do the right thing for // collapsed ranges inside block elements that contain nothing but a solo //
. It's easier/ to put a workaround here than to revamp them. :-( // XXX This sounds odd in the cases using `GetWhiteSpaceEndPoint()`. Don't // we hack something in the edit sub-action handlers? if (aStartRef != aEndRef) { return; } if (!aStartRef.Container()->IsContent()) { return; } Element* blockElement = HTMLEditUtils::GetInclusiveAncestorBlockElement( *aStartRef.Container()->AsContent()); if (!blockElement) { return; } Element* editingHost = GetActiveEditingHost(); if (NS_WARN_IF(!editingHost)) { return; } // Make sure we don't go higher than our root element in the content tree if (editingHost->IsInclusiveDescendantOf(blockElement)) { return; } if (IsEmptyNode(*blockElement, true, false)) { aStartRef = {blockElement, 0u}; aEndRef = {blockElement, blockElement->Length()}; } } already_AddRefed HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( const AbstractRange& aAbstractRange) { if (!aAbstractRange.IsPositioned()) { return nullptr; } return CreateRangeIncludingAdjuscentWhiteSpaces(aAbstractRange.StartRef(), aAbstractRange.EndRef()); } template already_AddRefed HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( const RangeBoundaryBase& aStartRef, const RangeBoundaryBase& aEndRef) { if (NS_WARN_IF(!aStartRef.IsSet()) || NS_WARN_IF(!aEndRef.IsSet())) { return nullptr; } if (!aStartRef.Container()->IsContent() || !aEndRef.Container()->IsContent()) { return nullptr; } RangeBoundaryBase startRef(aStartRef); RangeBoundaryBase endRef(aEndRef); SelectBRElementIfCollapsedInEmptyBlock(startRef, endRef); // For text actions, we want to look backwards (or forwards, as // appropriate) for additional white-space or nbsp's. We may have to act // on these later even though they are outside of the initial selection. // Even if they are in another node! // XXX Although the comment mentioned that this may scan other text nodes, // GetWhiteSpaceEndPoint() scans only in given container node. // XXX Looks like that we should make GetWhiteSpaceEndPoint() be a // instance method and stop scanning white-spaces when it reaches // active editing host. EditorDOMPoint startPoint = HTMLEditor::GetWhiteSpaceEndPoint( startRef, HTMLEditor::ScanDirection::Backward); if (!IsDescendantOfEditorRoot( EditorBase::GetNodeAtRangeOffsetPoint(startPoint))) { return nullptr; } EditorDOMPoint endPoint = HTMLEditor::GetWhiteSpaceEndPoint( endRef, HTMLEditor::ScanDirection::Forward); EditorRawDOMPoint lastRawPoint(endPoint); lastRawPoint.RewindOffset(); if (!IsDescendantOfEditorRoot( EditorBase::GetNodeAtRangeOffsetPoint(lastRawPoint))) { return nullptr; } RefPtr range = nsRange::Create(startPoint.ToRawRangeBoundary(), endPoint.ToRawRangeBoundary(), IgnoreErrors()); NS_WARNING_ASSERTION(range, "nsRange::Create() failed"); return range.forget(); } already_AddRefed HTMLEditor::CreateRangeExtendedToHardLineStartAndEnd( const AbstractRange& aAbstractRange, EditSubAction aEditSubAction) const { if (!aAbstractRange.IsPositioned()) { return nullptr; } return CreateRangeExtendedToHardLineStartAndEnd( aAbstractRange.StartRef(), aAbstractRange.EndRef(), aEditSubAction); } template already_AddRefed HTMLEditor::CreateRangeExtendedToHardLineStartAndEnd( const RangeBoundaryBase& aStartRef, const RangeBoundaryBase& aEndRef, EditSubAction aEditSubAction) const { if (NS_WARN_IF(!aStartRef.IsSet()) || NS_WARN_IF(!aEndRef.IsSet())) { return nullptr; } RangeBoundaryBase startRef(aStartRef); RangeBoundaryBase endRef(aEndRef); SelectBRElementIfCollapsedInEmptyBlock(startRef, endRef); // 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. EditorDOMPoint startPoint = GetCurrentHardLineStartPoint(startRef, aEditSubAction); // XXX GetCurrentHardLineStartPoint() may return point of editing // host. Perhaps, we should change it and stop checking it here // since this check may be expensive. if (!IsDescendantOfEditorRoot( EditorBase::GetNodeAtRangeOffsetPoint(startPoint))) { return nullptr; } EditorDOMPoint endPoint = GetCurrentHardLineEndPoint(endRef); EditorRawDOMPoint lastRawPoint(endPoint); lastRawPoint.RewindOffset(); // XXX GetCurrentHardLineEndPoint() may return point of editing host. // Perhaps, we should change it and stop checking it here since this // check may be expensive. if (!IsDescendantOfEditorRoot( EditorBase::GetNodeAtRangeOffsetPoint(lastRawPoint))) { return nullptr; } RefPtr range = nsRange::Create(startPoint.ToRawRangeBoundary(), endPoint.ToRawRangeBoundary(), IgnoreErrors()); NS_WARNING_ASSERTION(range, "nsRange::Create() failed"); return range.forget(); } nsresult HTMLEditor::SplitInlinesAndCollectEditTargetNodes( nsTArray>& aArrayOfRanges, nsTArray>& aOutArrayOfContents, EditSubAction aEditSubAction, CollectNonEditableNodes aCollectNonEditableNodes) { nsresult rv = SplitTextNodesAtRangeEnd(aArrayOfRanges); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::SplitTextNodesAtRangeEnd() failed"); if (NS_FAILED(rv)) { return rv; } rv = SplitParentInlineElementsAtRangeEdges(aArrayOfRanges); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::SplitParentInlineElementsAtRangeEdges() failed"); if (NS_FAILED(rv)) { return rv; } rv = CollectEditTargetNodes(aArrayOfRanges, aOutArrayOfContents, aEditSubAction, aCollectNonEditableNodes); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollectEditTargetNodes() failed"); if (NS_FAILED(rv)) { return rv; } rv = MaybeSplitElementsAtEveryBRElement(aOutArrayOfContents, aEditSubAction); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::MaybeSplitElementsAtEveryBRElement() failed"); return rv; } nsresult HTMLEditor::SplitTextNodesAtRangeEnd( nsTArray>& aArrayOfRanges) { // 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. ErrorResult error; IgnoredErrorResult ignoredError; for (RefPtr& range : aArrayOfRanges) { EditorDOMPoint atEnd(range->EndRef()); if (NS_WARN_IF(!atEnd.IsSet()) || !atEnd.IsInTextNode()) { continue; } if (!atEnd.IsStartOfContainer() && !atEnd.IsEndOfContainer()) { // Split the text node. nsCOMPtr newLeftNode = SplitNodeWithTransaction(atEnd, error); if (NS_WARN_IF(Destroyed())) { error = NS_ERROR_EDITOR_DESTROYED; } if (error.Failed()) { NS_WARNING_ASSERTION(error.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED), "HTMLEditor::SplitNodeWithTransaction() failed"); return error.StealNSResult(); } // Correct the range. // The new end parent becomes the parent node of the text. EditorRawDOMPoint atContainerOfSplitNode(atEnd.GetContainer()); MOZ_ASSERT(!range->IsInSelection()); range->SetEnd(atContainerOfSplitNode, ignoredError); NS_WARNING_ASSERTION(!ignoredError.Failed(), "nsRange::SetEnd() failed, but ignored"); ignoredError.SuppressException(); } } return NS_OK; } nsresult HTMLEditor::SplitParentInlineElementsAtRangeEdges( nsTArray>& aArrayOfRanges) { nsTArray> rangeItemArray; rangeItemArray.AppendElements(aArrayOfRanges.Length()); // First register ranges for special editor gravity for (auto& rangeItem : rangeItemArray) { rangeItem = new RangeItem(); rangeItem->StoreRange(*aArrayOfRanges[0]); RangeUpdaterRef().RegisterRangeItem(*rangeItem); aArrayOfRanges.RemoveElementAt(0); } // Now bust up inlines. nsresult rv = NS_OK; for (auto& item : Reversed(rangeItemArray)) { // MOZ_KnownLive because 'rangeItemArray' is guaranteed to keep it alive. rv = SplitParentInlineElementsAtRangeEdges(MOZ_KnownLive(*item)); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::SplitParentInlineElementsAtRangeEdges() failed"); break; } } // Then unregister the ranges for (auto& item : rangeItemArray) { RangeUpdaterRef().DropRangeItem(item); RefPtr range = item->GetRange(); if (range) { aArrayOfRanges.AppendElement(range); } } if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } return NS_OK; } nsresult HTMLEditor::CollectEditTargetNodes( nsTArray>& aArrayOfRanges, nsTArray>& aOutArrayOfContents, EditSubAction aEditSubAction, CollectNonEditableNodes aCollectNonEditableNodes) { MOZ_ASSERT(IsEditActionDataAvailable()); // Gather up a list of all the nodes for (auto& range : aArrayOfRanges) { 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 = aOutArrayOfContents.Length(); i > 0; --i) { if (!EditorUtils::IsEditableContent(aOutArrayOfContents[i - 1], EditorType::HTML)) { aOutArrayOfContents.RemoveElementAt(i - 1); } } } } 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. for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) { OwningNonNull content = aOutArrayOfContents[i]; if (HTMLEditUtils::IsListItem(content)) { aOutArrayOfContents.RemoveElementAt(i); CollectChildren(*content, aOutArrayOfContents, i, CollectListChildren::Yes, CollectTableChildren::Yes, aCollectNonEditableNodes); } } // 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 (!IsVisibleTextNode(*text)) { aOutArrayOfContents.RemoveElementAt(i); } } } break; case EditSubAction::eCreateOrChangeList: { 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)) { // XXX aCollectNonEditableNodes is ignored here. Maybe a bug. aOutArrayOfContents.RemoveElementAt(i - 1); CollectChildren(content, aOutArrayOfContents, i - 1, CollectListChildren::No, CollectTableChildren::Yes, CollectNonEditableNodes::Yes); } } // 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 = GetDeepestEditableOnlyChildDivBlockquoteOrListElement( aOutArrayOfContents[0]); 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. CollectChildren(*deepestDivBlockquoteOrListElement, aOutArrayOfContents, 0, CollectListChildren::No, CollectTableChildren::No, CollectNonEditableNodes::Yes); 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 for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) { OwningNonNull content = aOutArrayOfContents[i]; if (HTMLEditUtils::IsAnyTableElementButNotTable(content)) { aOutArrayOfContents.RemoveElementAt(i); CollectChildren(*content, aOutArrayOfContents, i, CollectListChildren::Yes, CollectTableChildren::Yes, aCollectNonEditableNodes); } } break; default: break; } // Outdent should look inside of divs. if (aEditSubAction == EditSubAction::eOutdent && !IsCSSEnabled()) { for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) { OwningNonNull content = aOutArrayOfContents[i]; if (content->IsHTMLElement(nsGkAtoms::div)) { aOutArrayOfContents.RemoveElementAt(i); CollectChildren(*content, aOutArrayOfContents, i, CollectListChildren::No, CollectTableChildren::No, aCollectNonEditableNodes); } } } return NS_OK; } nsresult HTMLEditor::MaybeSplitElementsAtEveryBRElement( nsTArray>& aArrayOfContents, EditSubAction aEditSubAction) { // Post-process the list to break up inline containers that contain br's, but // only for operations that might care, like making lists or paragraphs switch (aEditSubAction) { case EditSubAction::eCreateOrRemoveBlock: case EditSubAction::eMergeBlockContents: case EditSubAction::eCreateOrChangeList: case EditSubAction::eSetOrClearAlignment: case EditSubAction::eSetPositionToAbsolute: case EditSubAction::eIndent: case EditSubAction::eOutdent: for (int32_t i = aArrayOfContents.Length() - 1; i >= 0; i--) { OwningNonNull& content = aArrayOfContents[i]; if (HTMLEditUtils::IsInlineElement(content) && HTMLEditUtils::IsContainerNode(content) && !content->IsText()) { AutoTArray, 24> arrayOfInlineContents; // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it // alive. nsresult rv = SplitElementsAtEveryBRElement(MOZ_KnownLive(content), arrayOfInlineContents); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::SplitElementsAtEveryBRElement() failed"); return rv; } // Put these nodes in aArrayOfContents, replacing the current node aArrayOfContents.RemoveElementAt(i); aArrayOfContents.InsertElementsAt(i, arrayOfInlineContents); } } return NS_OK; default: return NS_OK; } } Element* HTMLEditor::GetParentListElementAtSelection() const { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); for (uint32_t i = 0; i < SelectionRefPtr()->RangeCount(); ++i) { nsRange* range = SelectionRefPtr()->GetRangeAt(i); for (nsINode* parent = range->GetClosestCommonInclusiveAncestor(); parent; parent = parent->GetParentNode()) { if (HTMLEditUtils::IsAnyListElement(parent)) { return parent->AsElement(); } } } return nullptr; } Element* HTMLEditor::GetDeepestEditableOnlyChildDivBlockquoteOrListElement( nsINode& aNode) { if (!aNode.IsElement()) { return nullptr; } // XXX If aNode is non-editable, shouldn't we return nullptr here? Element* parentElement = nullptr; for (nsIContent* content = aNode.AsContent(); content && content->IsElement() && (content->IsAnyOfHTMLElements(nsGkAtoms::div, nsGkAtoms::blockquote) || HTMLEditUtils::IsAnyListElement(content)); content = content->GetFirstChild()) { if (CountEditableChildren(content) != 1) { return content->AsElement(); } parentElement = content->AsElement(); } return parentElement; } nsresult HTMLEditor::SplitParentInlineElementsAtRangeEdges( RangeItem& aRangeItem) { MOZ_ASSERT(IsEditActionDataAvailable()); if (!aRangeItem.IsCollapsed()) { nsCOMPtr mostAncestorInlineContentAtEnd = GetMostAncestorInlineElement(*aRangeItem.mEndContainer); if (mostAncestorInlineContentAtEnd) { SplitNodeResult splitEndInlineResult = SplitNodeDeepWithTransaction( *mostAncestorInlineContentAtEnd, aRangeItem.EndPoint(), SplitAtEdges::eDoNotCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (splitEndInlineResult.Failed()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) failed"); return splitEndInlineResult.Rv(); } EditorRawDOMPoint splitPointAtEnd(splitEndInlineResult.SplitPoint()); if (!splitPointAtEnd.IsSet()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) didn't return split point"); return NS_ERROR_FAILURE; } aRangeItem.mEndContainer = splitPointAtEnd.GetContainer(); aRangeItem.mEndOffset = splitPointAtEnd.Offset(); } } nsCOMPtr mostAncestorInlineContentAtStart = GetMostAncestorInlineElement(*aRangeItem.mStartContainer); if (mostAncestorInlineContentAtStart) { SplitNodeResult splitStartInlineResult = SplitNodeDeepWithTransaction( *mostAncestorInlineContentAtStart, aRangeItem.StartPoint(), SplitAtEdges::eDoNotCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (splitStartInlineResult.Failed()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) failed"); return splitStartInlineResult.Rv(); } // XXX If we split only here because of collapsed range, we're modifying // only start point of aRangeItem. Shouldn't we modify end point here // if it's collapsed? EditorRawDOMPoint splitPointAtStart(splitStartInlineResult.SplitPoint()); if (!splitPointAtStart.IsSet()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eDoNotCreateEmptyContainer) didn't return split point"); return NS_ERROR_FAILURE; } aRangeItem.mStartContainer = splitPointAtStart.GetContainer(); aRangeItem.mStartOffset = splitPointAtStart.Offset(); } return NS_OK; } nsresult HTMLEditor::SplitElementsAtEveryBRElement( nsIContent& aMostAncestorToBeSplit, nsTArray>& aOutArrayOfContents) { MOZ_ASSERT(IsEditActionDataAvailable()); // First build up a list of all the break nodes inside the inline container. AutoTArray, 24> arrayOfBRElements; DOMIterator iter(aMostAncestorToBeSplit); iter.AppendAllNodesToArray(arrayOfBRElements); // If there aren't any breaks, just put inNode itself in the array if (arrayOfBRElements.IsEmpty()) { aOutArrayOfContents.AppendElement(aMostAncestorToBeSplit); return NS_OK; } // Else we need to bust up aMostAncestorToBeSplit along all the breaks nsCOMPtr nextContent = &aMostAncestorToBeSplit; for (OwningNonNull& brElement : arrayOfBRElements) { EditorDOMPoint atBRNode(brElement); if (NS_WARN_IF(!atBRNode.IsSet())) { return NS_ERROR_FAILURE; } SplitNodeResult splitNodeResult = SplitNodeDeepWithTransaction( *nextContent, atBRNode, SplitAtEdges::eAllowToCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (splitNodeResult.Failed()) { NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed"); return splitNodeResult.Rv(); } // Put previous node at the split point. if (splitNodeResult.GetPreviousNode()) { // Might not be a left node. A break might have been at the very // beginning of inline container, in which case // SplitNodeDeepWithTransaction() would not actually split anything. aOutArrayOfContents.AppendElement(*splitNodeResult.GetPreviousNode()); } // Move break outside of container and also put in node list EditorDOMPoint atNextNode(splitNodeResult.GetNextNode()); // MOZ_KnownLive because 'arrayOfBRElements' is guaranteed to keep it alive. nsresult rv = MoveNodeWithTransaction(MOZ_KnownLive(brElement), atNextNode); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); return rv; } aOutArrayOfContents.AppendElement(brElement); nextContent = splitNodeResult.GetNextNode(); } // Now tack on remaining next node. aOutArrayOfContents.AppendElement(*nextContent); return NS_OK; } nsIContent* HTMLEditor::GetMostAncestorInlineElement(nsINode& aNode) const { MOZ_ASSERT(IsEditActionDataAvailable()); if (!aNode.IsContent() || HTMLEditUtils::IsBlockElement(*aNode.AsContent())) { return nullptr; } Element* host = GetActiveEditingHost(); if (NS_WARN_IF(!host)) { return nullptr; } // If aNode is the editing host itself, there is no modifiable inline // parent. if (&aNode == host) { return nullptr; } // If aNode is outside of the element, we don't support to edit // such elements for now. // XXX This should be MOZ_ASSERT after fixing bug 1413131 for avoiding // calling this expensive method. if (NS_WARN_IF(!EditorUtils::IsDescendantOf(aNode, *host))) { return nullptr; } if (!aNode.GetParent()) { return aNode.AsContent(); } // Looks for the highest inline parent in the editing host. nsIContent* topMostInlineContent = aNode.AsContent(); for (nsIContent* content : aNode.AncestorsOfType()) { if (content == host || !HTMLEditUtils::IsInlineElement(*content)) { break; } topMostInlineContent = content; } return topMostInlineContent; } // static void HTMLEditor::MakeTransitionList( const nsTArray>& aArrayOfContents, nsTArray& aTransitionArray) { nsINode* prevParent = nullptr; aTransitionArray.EnsureLengthAtLeast(aArrayOfContents.Length()); for (uint32_t i = 0; i < aArrayOfContents.Length(); i++) { aTransitionArray[i] = aArrayOfContents[i]->GetParentNode() != prevParent; prevParent = aArrayOfContents[i]->GetParentNode(); } } Element* HTMLEditor::GetNearestAncestorListItemElement( nsIContent& aContent) const { // XXX Why don't we test whether aContent is in an editing host? if (HTMLEditUtils::IsListItem(&aContent)) { return aContent.AsElement(); } // XXX This loop is too expensive since calling IsDescendantOfEditorRoot() // a lot. Rewrite this with caching active editing host and check // whether we reach it or not. for (Element* parentElement = aContent.GetParentElement(); parentElement && IsDescendantOfEditorRoot(parentElement) && !HTMLEditUtils::IsAnyTableElement(parentElement); parentElement = parentElement->GetParentElement()) { if (HTMLEditUtils::IsListItem(parentElement)) { return parentElement; } } return nullptr; } nsresult HTMLEditor::HandleInsertParagraphInHeadingElement(Element& aHeader, nsINode& aNode, int32_t aOffset) { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); // Remember where the header is nsCOMPtr headerParent = aHeader.GetParentNode(); int32_t offset = headerParent ? headerParent->ComputeIndexOf(&aHeader) : -1; // Get ws code to adjust any ws nsCOMPtr node = &aNode; nsresult rv = WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks( *this, address_of(node), &aOffset); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING( "WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks() failed"); return rv; } if (!node->IsContent()) { NS_WARNING( "WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks() returned " "Document or something non-content node"); return NS_ERROR_FAILURE; } // Split the header SplitNodeResult splitHeaderResult = SplitNodeDeepWithTransaction(aHeader, EditorDOMPoint(node, aOffset), SplitAtEdges::eAllowToCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( splitHeaderResult.Succeeded(), "HTMLEditor::SplitNodeDeepWithTransaction() failed, but ignored"); // If the previous heading of split point is empty, put a padding
// element for empty last line into it. nsCOMPtr prevItem = GetPriorHTMLSibling(&aHeader); if (prevItem) { MOZ_DIAGNOSTIC_ASSERT(HTMLEditUtils::IsHeader(*prevItem)); if (IsEmptyNode(*prevItem)) { CreateElementResult createPaddingBRResult = InsertPaddingBRElementForEmptyLastLineWithTransaction( EditorDOMPoint(prevItem, 0)); if (createPaddingBRResult.Failed()) { NS_WARNING( "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction(" ") failed"); return createPaddingBRResult.Rv(); } } } // If the new (righthand) header node is empty, delete it if (IsEmptyBlockElement(aHeader, IgnoreSingleBR::Yes)) { nsresult rv = DeleteNodeWithTransaction(aHeader); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } // Layout tells the caret to blink in a weird place if we don't place a // break after the header. nsCOMPtr sibling; if (aHeader.GetNextSibling()) { sibling = GetNextHTMLSibling(aHeader.GetNextSibling()); } if (!sibling || !sibling->IsHTMLElement(nsGkAtoms::br)) { TopLevelEditSubActionDataRef().mCachedInlineStyles->Clear(); mTypeInState->ClearAllProps(); // Create a paragraph nsStaticAtom& paraAtom = DefaultParagraphSeparatorTagName(); // We want a wrapper element even if we separate with
EditorDOMPoint nextToHeader(headerParent, offset + 1); RefPtr pOrDivElement = CreateNodeWithTransaction( ¶Atom == nsGkAtoms::br ? *nsGkAtoms::p : MOZ_KnownLive(paraAtom), nextToHeader); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!pOrDivElement) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // Append a
to it RefPtr brElement = InsertBRElementWithTransaction(EditorDOMPoint(pOrDivElement, 0)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!brElement) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return NS_ERROR_FAILURE; } // Set selection to before the break nsresult rv = CollapseSelectionToStartOf(*pOrDivElement); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } EditorRawDOMPoint afterSibling(EditorRawDOMPoint::After(*sibling)); if (NS_WARN_IF(!afterSibling.IsSet())) { return NS_ERROR_FAILURE; } // Put selection after break rv = CollapseSelectionTo(afterSibling); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } // Put selection at front of righthand heading rv = CollapseSelectionToStartOf(aHeader); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } EditActionResult HTMLEditor::HandleInsertParagraphInParagraph( Element& aParentDivOrP) { MOZ_ASSERT(IsEditActionDataAvailable()); nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return EditActionResult(NS_ERROR_FAILURE); } EditorDOMPoint atStartOfSelection(firstRange->StartRef()); if (NS_WARN_IF(!atStartOfSelection.IsSet())) { return EditActionResult(NS_ERROR_FAILURE); } MOZ_ASSERT(atStartOfSelection.IsSetAndValid()); // We shouldn't create new anchor element which has non-empty href unless // splitting middle of it because we assume that users don't want to create // *same* anchor element across two or more paragraphs in most cases. // So, adjust selection start if it's edge of anchor element(s). // XXX We don't support white-space collapsing in these cases since it needs // some additional work with WhiteSpaceVisibilityKeeper but it's not usual // case. E.g., |foo [] | if (atStartOfSelection.IsStartOfContainer()) { for (nsIContent* container = atStartOfSelection.GetContainerAsContent(); container && container != &aParentDivOrP; container = container->GetParent()) { if (HTMLEditUtils::IsLink(container)) { // Found link should be only in right node. So, we shouldn't split // it. atStartOfSelection.Set(container); // Even if we found an anchor element, don't break because DOM API // allows to nest anchor elements. } // If the container is middle of its parent, stop adjusting split point. if (container->GetPreviousSibling()) { // XXX Should we check if previous sibling is visible content? // E.g., should we ignore comment node, invisible
element? break; } } } // We also need to check if selection is at invisible
element at end // of an element because editor inserts a
element when // user types Enter key after a white-space which is at middle of // element and when setting selection at end of the element, // selection becomes referring the
element. We may need to change this // behavior later if it'd be standardized. else if (atStartOfSelection.IsEndOfContainer() || atStartOfSelection.IsBRElementAtEndOfContainer()) { // If there are 2
elements, the first
element is visible. E.g., // |boo[]

|, we should split the // element. Otherwise, E.g., |boo[]
|, // we should not split the element and ignore inline elements in it. bool foundBRElement = atStartOfSelection.IsBRElementAtEndOfContainer(); for (nsIContent* container = atStartOfSelection.GetContainerAsContent(); container && container != &aParentDivOrP; container = container->GetParent()) { if (HTMLEditUtils::IsLink(container)) { // Found link should be only in left node. So, we shouldn't split it. atStartOfSelection.SetAfter(container); // Even if we found an anchor element, don't break because DOM API // allows to nest anchor elements. } // If the container is middle of its parent, stop adjusting split point. if (nsIContent* nextSibling = container->GetNextSibling()) { if (foundBRElement) { // If we've already found a
element, we assume found node is // visible
or something other node. // XXX Should we check if non-text data node like comment? break; } // XXX Should we check if non-text data node like comment? if (!nextSibling->IsHTMLElement(nsGkAtoms::br)) { break; } foundBRElement = true; } } } bool doesCRCreateNewP = GetReturnInParagraphCreatesNewParagraph(); bool splitAfterNewBR = false; nsCOMPtr brContent; EditorDOMPoint pointToSplitParentDivOrP(atStartOfSelection); EditorDOMPoint pointToInsertBR; if (doesCRCreateNewP && atStartOfSelection.GetContainer() == &aParentDivOrP) { // We are at the edges of the block, so, we don't need to create new
. brContent = nullptr; } else if (atStartOfSelection.IsInTextNode()) { // at beginning of text node? if (atStartOfSelection.IsStartOfContainer()) { // is there a BR prior to it? brContent = GetPriorHTMLSibling(atStartOfSelection.GetContainer()); if (!brContent || !IsVisibleBRElement(brContent) || EditorUtils::IsPaddingBRElementForEmptyLastLine(*brContent)) { pointToInsertBR.Set(atStartOfSelection.GetContainer()); brContent = nullptr; } } else if (atStartOfSelection.IsEndOfContainer()) { // we're at the end of text node... // is there a BR after to it? brContent = GetNextHTMLSibling(atStartOfSelection.GetContainer()); if (!brContent || !IsVisibleBRElement(brContent) || EditorUtils::IsPaddingBRElementForEmptyLastLine(*brContent)) { pointToInsertBR.SetAfter(atStartOfSelection.GetContainer()); NS_WARNING_ASSERTION( pointToInsertBR.IsSet(), "Failed to set to after the container of selection start"); brContent = nullptr; } } else { if (doesCRCreateNewP) { ErrorResult error; nsCOMPtr newLeftDivOrP = SplitNodeWithTransaction(pointToSplitParentDivOrP, error); if (NS_WARN_IF(Destroyed())) { error = NS_ERROR_EDITOR_DESTROYED; } if (error.Failed()) { NS_WARNING_ASSERTION(error.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED), "HTMLEditor::SplitNodeWithTransaction() failed"); return EditActionResult(error.StealNSResult()); } pointToSplitParentDivOrP.SetToEndOf(newLeftDivOrP); } // We need to put new
after the left node if given node was split // above. pointToInsertBR.Set(pointToSplitParentDivOrP.GetContainer()); DebugOnly advanced = pointToInsertBR.AdvanceOffset(); NS_WARNING_ASSERTION(advanced, "Failed to advance offset to after the container " "of selection start"); } } else { // not in a text node. // is there a BR prior to it? nsCOMPtr nearContent = GetPreviousEditableHTMLNode(atStartOfSelection); if (!nearContent || !IsVisibleBRElement(nearContent) || EditorUtils::IsPaddingBRElementForEmptyLastLine(*nearContent)) { // is there a BR after it? nearContent = GetNextEditableHTMLNode(atStartOfSelection); if (!nearContent || !IsVisibleBRElement(nearContent) || EditorUtils::IsPaddingBRElementForEmptyLastLine(*nearContent)) { pointToInsertBR = atStartOfSelection; splitAfterNewBR = true; } } if (!pointToInsertBR.IsSet() && nearContent->IsHTMLElement(nsGkAtoms::br)) { brContent = nearContent; } } if (pointToInsertBR.IsSet()) { // if CR does not create a new P, default to BR creation if (NS_WARN_IF(!doesCRCreateNewP)) { return EditActionResult(NS_OK); } brContent = InsertBRElementWithTransaction(pointToInsertBR); if (NS_WARN_IF(Destroyed())) { return EditActionResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION( brContent, "HTMLEditor::InsertBRElementWithTransaction() failed, but ignored"); if (splitAfterNewBR) { // We split the parent after the br we've just inserted. pointToSplitParentDivOrP.SetAfter(brContent); NS_WARNING_ASSERTION(pointToSplitParentDivOrP.IsSet(), "Failed to set after the new
"); } } EditActionResult result( SplitParagraph(aParentDivOrP, pointToSplitParentDivOrP, brContent)); NS_WARNING_ASSERTION(result.Succeeded(), "HTMLEditor::SplitParagraph() failed"); result.MarkAsHandled(); return result; } template nsresult HTMLEditor::SplitParagraph( Element& aParentDivOrP, const EditorDOMPointBase& aStartOfRightNode, nsIContent* aNextBRNode) { MOZ_ASSERT(IsEditActionDataAvailable()); nsCOMPtr selNode = aStartOfRightNode.GetContainer(); int32_t selOffset = aStartOfRightNode.Offset(); nsresult rv = WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks( *this, address_of(selNode), &selOffset); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING( "WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks() failed"); return rv; } if (!selNode->IsContent()) { NS_WARNING( "WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks() returned " "Document or something non-content node"); return NS_ERROR_FAILURE; } // Split the paragraph. SplitNodeResult splitDivOrPResult = SplitNodeDeepWithTransaction( aParentDivOrP, EditorDOMPoint(selNode, selOffset), SplitAtEdges::eAllowToCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (splitDivOrPResult.Failed()) { NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed"); return splitDivOrPResult.Rv(); } if (!splitDivOrPResult.DidSplit()) { NS_WARNING( "HTMLEditor::SplitNodeDeepWithTransaction() didn't split any nodes"); return NS_ERROR_FAILURE; } // Get rid of the break, if it is visible (otherwise it may be needed to // prevent an empty p). if (aNextBRNode && IsVisibleBRElement(aNextBRNode)) { rv = DeleteNodeWithTransaction(*aNextBRNode); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } } // Remove ID attribute on the paragraph from the existing right node. rv = RemoveAttributeWithTransaction(aParentDivOrP, *nsGkAtoms::id); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING( "EditorBase::RemoveAttributeWithTransaction(nsGkAtoms::id) failed"); return rv; } // We need to ensure to both paragraphs visible even if they are empty. // However, padding
element for empty last line isn't useful in this // case because it'll be ignored by PlaintextSerializer. Additionally, // it'll be exposed as
with Element.innerHTML. Therefore, we can use // normal
elements for placeholder in this case. Note that Chromium // also behaves so. if (splitDivOrPResult.GetPreviousNode()->IsElement()) { rv = InsertBRElementIfEmptyBlockElement( MOZ_KnownLive(*splitDivOrPResult.GetPreviousNode()->AsElement())); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::InsertBRElementIfEmptyBlockElement() failed"); return rv; } } if (splitDivOrPResult.GetNextNode()->IsElement()) { rv = InsertBRElementIfEmptyBlockElement( MOZ_KnownLive(*splitDivOrPResult.GetNextNode()->AsElement())); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::InsertBRElementIfEmptyBlockElement() failed"); return rv; } } // selection to beginning of right hand para; // look inside any containers that are up front. nsCOMPtr child = HTMLEditUtils::GetFirstLeafChild( aParentDivOrP, ChildBlockBoundary::TreatAsLeaf); if (child && (child->IsText() || HTMLEditUtils::IsContainerNode(*child))) { nsresult rv = CollapseSelectionToStartOf(*child); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed, but ignored"); } else { nsresult rv = CollapseSelectionTo(EditorRawDOMPoint(child)); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed, but ignored"); } return NS_OK; } nsresult HTMLEditor::HandleInsertParagraphInListItemElement(Element& aListItem, nsINode& aNode, int32_t aOffset) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(HTMLEditUtils::IsListItem(&aListItem)); // Get the item parent and the active editing host. RefPtr host = GetActiveEditingHost(); // If we are in an empty item, then we want to pop up out of the list, but // only if prefs say it's okay and if the parent isn't the active editing // host. if (host != aListItem.GetParentElement() && IsEmptyBlockElement(aListItem, IgnoreSingleBR::Yes)) { nsCOMPtr leftListNode = aListItem.GetParent(); // Are we the last list item in the list? if (!IsLastEditableChild(&aListItem)) { // We need to split the list! EditorDOMPoint atListItem(&aListItem); ErrorResult error; leftListNode = SplitNodeWithTransaction(atListItem, error); if (NS_WARN_IF(Destroyed())) { error = NS_ERROR_EDITOR_DESTROYED; } if (error.Failed()) { NS_WARNING_ASSERTION(error.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED), "HTMLEditor::SplitNodeWithTransaction() failed"); return error.StealNSResult(); } } // Are we in a sublist? EditorDOMPoint atNextSiblingOfLeftList(leftListNode); DebugOnly advanced = atNextSiblingOfLeftList.AdvanceOffset(); NS_WARNING_ASSERTION(advanced, "Failed to advance offset after the right list node"); if (HTMLEditUtils::IsAnyListElement( atNextSiblingOfLeftList.GetContainer())) { // If so, move item out of this list and into the grandparent list nsresult rv = MoveNodeWithTransaction(aListItem, atNextSiblingOfLeftList); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); return rv; } rv = CollapseSelectionToStartOf(aListItem); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } // Otherwise kill this item nsresult rv = DeleteNodeWithTransaction(aListItem); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } // Time to insert a paragraph nsStaticAtom& paraAtom = DefaultParagraphSeparatorTagName(); // We want a wrapper even if we separate with
RefPtr pOrDivElement = CreateNodeWithTransaction( ¶Atom == nsGkAtoms::br ? *nsGkAtoms::p : MOZ_KnownLive(paraAtom), atNextSiblingOfLeftList); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!pOrDivElement) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // Append a
to it RefPtr brElement = InsertBRElementWithTransaction(EditorDOMPoint(pOrDivElement, 0)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!brElement) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return NS_ERROR_FAILURE; } // Set selection to before the break rv = CollapseSelectionToStartOf(*pOrDivElement); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } // Else we want a new list item at the same list level. Get ws code to // adjust any ws. nsCOMPtr selNode = &aNode; nsresult rv = WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks( *this, address_of(selNode), &aOffset); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING( "WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks() failed"); return rv; } if (!selNode->IsContent()) { NS_WARNING( "WhiteSpaceVisibilityKeeper::PrepareToSplitAcrossBlocks() returned " "document node or something non-content node"); return NS_ERROR_FAILURE; } // Now split the list item. SplitNodeResult splitListItemResult = SplitNodeDeepWithTransaction(aListItem, EditorDOMPoint(selNode, aOffset), SplitAtEdges::eAllowToCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( splitListItemResult.Succeeded(), "HTMLEditor::SplitNodeDeepWithTransaction() failed, but ignored"); // Hack: until I can change the damaged doc range code back to being // extra-inclusive, I have to manually detect certain list items that may be // left empty. nsCOMPtr prevItem = GetPriorHTMLSibling(&aListItem); if (prevItem && HTMLEditUtils::IsListItem(prevItem)) { if (IsEmptyNode(*prevItem)) { CreateElementResult createPaddingBRResult = InsertPaddingBRElementForEmptyLastLineWithTransaction( EditorDOMPoint(prevItem, 0)); if (createPaddingBRResult.Failed()) { NS_WARNING( "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction(" ") failed"); return createPaddingBRResult.Rv(); } } else { if (IsEmptyNode(aListItem, true)) { if (aListItem.IsAnyOfHTMLElements(nsGkAtoms::dd, nsGkAtoms::dt)) { nsCOMPtr list = aListItem.GetParentNode(); int32_t itemOffset = list ? list->ComputeIndexOf(&aListItem) : -1; nsStaticAtom* nextDefinitionListItemTagName = aListItem.IsHTMLElement(nsGkAtoms::dt) ? nsGkAtoms::dd : nsGkAtoms::dt; MOZ_DIAGNOSTIC_ASSERT(itemOffset != -1); EditorDOMPoint atNextListItem(list, aListItem.GetNextSibling(), itemOffset + 1); RefPtr newListItem = CreateNodeWithTransaction( MOZ_KnownLive(*nextDefinitionListItemTagName), atNextListItem); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!newListItem) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } nsresult rv = DeleteNodeWithTransaction(aListItem); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } rv = CollapseSelectionToStartOf(*newListItem); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } RefPtr brElement; nsresult rv = CopyLastEditableChildStylesWithTransaction( MOZ_KnownLive(*prevItem->AsElement()), aListItem, address_of(brElement)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::CopyLastEditableChildStylesWithTransaction() " "failed"); return NS_ERROR_FAILURE; } if (brElement) { EditorRawDOMPoint atBRNode(brElement); if (NS_WARN_IF(!atBRNode.IsSetAndValid())) { return NS_ERROR_FAILURE; } nsresult rv = CollapseSelectionTo(atBRNode); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } } else { WSScanResult forwardScanFromStartOfListItemResult = WSRunScanner::ScanNextVisibleNodeOrBlockBoundary( *this, EditorRawDOMPoint(&aListItem, 0)); if (forwardScanFromStartOfListItemResult.Failed()) { NS_WARNING( "WSRunScanner::ScanNextVisibleNodeOrBlockBoundary() failed"); return NS_ERROR_FAILURE; } if (forwardScanFromStartOfListItemResult.ReachedSpecialContent() || forwardScanFromStartOfListItemResult.ReachedBRElement() || forwardScanFromStartOfListItemResult.ReachedHRElement()) { EditorRawDOMPoint atFoundElement( forwardScanFromStartOfListItemResult.RawPointAtContent()); if (NS_WARN_IF(!atFoundElement.IsSetAndValid())) { return NS_ERROR_FAILURE; } nsresult rv = CollapseSelectionTo(atFoundElement); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } // XXX This may be not meaningful position if it reached block element // in aListItem. nsresult rv = CollapseSelectionTo( forwardScanFromStartOfListItemResult.RawPoint()); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } } } rv = CollapseSelectionToStartOf(aListItem); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionToStartOf() failed"); return rv; } nsresult HTMLEditor::MoveNodesIntoNewBlockquoteElement( nsTArray>& aArrayOfContents) { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); // The idea here is to put the nodes into a minimal number of blockquotes. // When the user blockquotes something, they expect one blockquote. That // may not be possible (for instance, if they have two table cells selected, // you need two blockquotes inside the cells). RefPtr curBlock; nsCOMPtr prevParent; for (auto& content : aArrayOfContents) { // If the node is a table element or list item, dive inside if (HTMLEditUtils::IsAnyTableElementButNotTable(content) || HTMLEditUtils::IsListItem(content)) { // Forget any previous block curBlock = nullptr; // Recursion time AutoTArray, 24> childContents; HTMLEditor::GetChildNodesOf(*content, childContents); nsresult rv = MoveNodesIntoNewBlockquoteElement(childContents); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodesIntoNewBlockquoteElement() failed"); return rv; } } // If the node has different parent than previous node, further nodes in a // new parent if (prevParent) { if (prevParent != content->GetParentNode()) { // Forget any previous blockquote node we were using curBlock = nullptr; prevParent = content->GetParentNode(); } } else { prevParent = content->GetParentNode(); } // If no curBlock, make one if (!curBlock) { SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(*nsGkAtoms::blockquote, EditorDOMPoint(content)); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction(nsGkAtoms:" ":blockquote) failed"); return splitNodeResult.Rv(); } // XXX Perhaps, we should insert the new `
` element after // moving all nodes into it since the movement does not cause // running mutation event listeners. curBlock = CreateNodeWithTransaction(*nsGkAtoms::blockquote, splitNodeResult.SplitPoint()); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!curBlock) { NS_WARNING( "EditorBase::CreateNodeWithTransaction(nsGkAtoms::blockquote) " "failed"); return NS_ERROR_FAILURE; } // remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = curBlock; // note: doesn't matter if we set mNewBlockElement multiple times. } // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to/ keep it alive. nsresult rv = MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *curBlock); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } } return NS_OK; } nsresult HTMLEditor::RemoveBlockContainerElements( nsTArray>& aArrayOfContents) { MOZ_ASSERT(IsEditActionDataAvailable()); // Intent of this routine is to be used for converting to/from headers, // paragraphs, pre, and address. Those blocks that pretty much just contain // inline things... RefPtr blockElement; nsCOMPtr firstContent, lastContent; for (auto& content : aArrayOfContents) { // If curNode is an
,
, , or
, remove it. if (HTMLEditUtils::IsFormatNode(content)) { // Process any partial progress saved if (blockElement) { SplitRangeOffFromNodeResult removeMiddleContainerResult = SplitRangeOffFromBlockAndRemoveMiddleContainer( *blockElement, *firstContent, *lastContent); if (removeMiddleContainerResult.Failed()) { NS_WARNING( "HTMLEditor::SplitRangeOffFromBlockAndRemoveMiddleContainer() " "failed"); return removeMiddleContainerResult.Rv(); } firstContent = lastContent = blockElement = nullptr; } if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { continue; } // Remove current block nsresult rv = RemoveBlockContainerWithTransaction( MOZ_KnownLive(*content->AsElement())); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return rv; } continue; } // XXX How about,
, ,
,
? if (content->IsAnyOfHTMLElements( nsGkAtoms::table, nsGkAtoms::tr, nsGkAtoms::tbody, nsGkAtoms::td, nsGkAtoms::li, nsGkAtoms::blockquote, nsGkAtoms::div) || HTMLEditUtils::IsAnyListElement(content)) { // Process any partial progress saved if (blockElement) { SplitRangeOffFromNodeResult removeMiddleContainerResult = SplitRangeOffFromBlockAndRemoveMiddleContainer( *blockElement, *firstContent, *lastContent); if (removeMiddleContainerResult.Failed()) { NS_WARNING( "HTMLEditor::SplitRangeOffFromBlockAndRemoveMiddleContainer() " "failed"); return removeMiddleContainerResult.Rv(); } firstContent = lastContent = blockElement = nullptr; } if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { continue; } // Recursion time AutoTArray, 24> childContents; HTMLEditor::GetChildNodesOf(*content, childContents); nsresult rv = RemoveBlockContainerElements(childContents); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::RemoveBlockContainerElements() failed"); return rv; } continue; } if (HTMLEditUtils::IsInlineElement(content)) { if (blockElement) { // If so, is this node a descendant? if (EditorUtils::IsDescendantOf(*content, *blockElement)) { // Then we don't need to do anything different for this node lastContent = content; continue; } // Otherwise, we have progressed beyond end of blockElement, so let's // handle it now. We need to remove the portion of blockElement that // contains [firstContent - lastContent]. SplitRangeOffFromNodeResult removeMiddleContainerResult = SplitRangeOffFromBlockAndRemoveMiddleContainer( *blockElement, *firstContent, *lastContent); if (removeMiddleContainerResult.Failed()) { NS_WARNING( "HTMLEditor::SplitRangeOffFromBlockAndRemoveMiddleContainer() " "failed"); return removeMiddleContainerResult.Rv(); } firstContent = lastContent = blockElement = nullptr; // Fall out and handle content } blockElement = HTMLEditUtils::GetAncestorBlockElement(content); if (!blockElement || !HTMLEditUtils::IsFormatNode(blockElement) || !EditorUtils::IsEditableContent(*blockElement, EditorType::HTML)) { // Not a block kind that we care about. blockElement = nullptr; } else { firstContent = lastContent = content; } continue; } if (blockElement) { // Some node that is already sans block style. Skip over it and process // any partial progress saved. SplitRangeOffFromNodeResult removeMiddleContainerResult = SplitRangeOffFromBlockAndRemoveMiddleContainer( *blockElement, *firstContent, *lastContent); if (removeMiddleContainerResult.Failed()) { NS_WARNING( "HTMLEditor::SplitRangeOffFromBlockAndRemoveMiddleContainer() " "failed"); return removeMiddleContainerResult.Rv(); } firstContent = lastContent = blockElement = nullptr; continue; } } // Process any partial progress saved if (blockElement) { SplitRangeOffFromNodeResult removeMiddleContainerResult = SplitRangeOffFromBlockAndRemoveMiddleContainer( *blockElement, *firstContent, *lastContent); if (removeMiddleContainerResult.Failed()) { NS_WARNING( "HTMLEditor::SplitRangeOffFromBlockAndRemoveMiddleContainer() " "failed"); return removeMiddleContainerResult.Rv(); } firstContent = lastContent = blockElement = nullptr; } return NS_OK; } nsresult HTMLEditor::CreateOrChangeBlockContainerElement( nsTArray>& aArrayOfContents, nsAtom& aBlockTag) { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); // Intent of this routine is to be used for converting to/from headers, // paragraphs, pre, and address. Those blocks that pretty much just contain // inline things... nsCOMPtr newBlock; nsCOMPtr curBlock; for (auto& content : aArrayOfContents) { EditorDOMPoint atContent(content); if (NS_WARN_IF(!atContent.IsInContentNode())) { // If given node has been removed from the document, let's ignore it // since the following code may need its parent replace it with new // block. curBlock = nullptr; newBlock = nullptr; continue; } // Is it already the right kind of block, or an uneditable block? if (content->IsHTMLElement(&aBlockTag) || (!EditorUtils::IsEditableContent(content, EditorType::HTML) && HTMLEditUtils::IsBlockElement(content))) { // Forget any previous block used for previous inline nodes curBlock = nullptr; // Do nothing to this block continue; } // If content is a address, p, header, address, or pre, replace it with a // new block of correct type. // XXX: pre can't hold everything the others can if (HTMLEditUtils::IsMozDiv(content) || HTMLEditUtils::IsFormatNode(content)) { // Forget any previous block used for previous inline nodes curBlock = nullptr; newBlock = ReplaceContainerAndCloneAttributesWithTransaction( MOZ_KnownLive(*content->AsElement()), aBlockTag); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!newBlock) { NS_WARNING( "EditorBase::ReplaceContainerAndCloneAttributesWithTransaction() " "failed"); return NS_ERROR_FAILURE; } // If the new block element was moved to different element or removed by // the web app via mutation event listener, we should stop handling this // action since we cannot handle each of a lot of edge cases. if (NS_WARN_IF(newBlock->GetParentNode() != atContent.GetContainer())) { return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } continue; } if (HTMLEditUtils::IsTable(content) || HTMLEditUtils::IsAnyListElement(content) || content->IsAnyOfHTMLElements(nsGkAtoms::tbody, nsGkAtoms::tr, nsGkAtoms::td, nsGkAtoms::li, nsGkAtoms::blockquote, nsGkAtoms::div)) { // Forget any previous block used for previous inline nodes curBlock = nullptr; // Recursion time AutoTArray, 24> childContents; HTMLEditor::GetChildNodesOf(*content, childContents); if (!childContents.IsEmpty()) { nsresult rv = CreateOrChangeBlockContainerElement(childContents, aBlockTag); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::CreateOrChangeBlockContainerElement() failed"); return rv; } continue; } // Make sure we can put a block here SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(aBlockTag, atContent); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() failed"); return splitNodeResult.Rv(); } // If current handling node has been moved from the container by a // mutation event listener when we need to do something more for it, // we should stop handling this action since we cannot handle each of // a lot of edge cases. if (NS_WARN_IF(atContent.HasChildMovedFromContainer())) { return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } EditorDOMPoint splitPoint = splitNodeResult.SplitPoint(); RefPtr theBlock = CreateNodeWithTransaction(aBlockTag, splitPoint); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!theBlock) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // If the new block element was moved to different element or removed by // the web app via mutation event listener, we should stop handling this // action since we cannot handle each of a lot of edge cases. if (NS_WARN_IF(theBlock->GetParentNode() != splitPoint.GetContainer())) { return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } // Remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = std::move(theBlock); continue; } if (content->IsHTMLElement(nsGkAtoms::br)) { // If the node is a break, we honor it by putting further nodes in a new // parent if (curBlock) { // Forget any previous block used for previous inline nodes curBlock = nullptr; // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it // alive. nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } continue; } // The break is the first (or even only) node we encountered. Create a // block for it. SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(aBlockTag, atContent); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() failed"); return splitNodeResult.Rv(); } // If current handling node has been moved from the container by a // mutation event listener when we need to do something more for it, // we should stop handling this action since we cannot handle each of // a lot of edge cases. if (NS_WARN_IF(atContent.HasChildMovedFromContainer())) { return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } EditorDOMPoint splitPoint = splitNodeResult.SplitPoint(); curBlock = CreateNodeWithTransaction(aBlockTag, splitPoint); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!curBlock) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // If the new block element was moved to different element or removed by // the web app via mutation event listener, we should stop handling this // action since we cannot handle each of a lot of edge cases. if (NS_WARN_IF(curBlock->GetParentNode() != splitPoint.GetContainer())) { return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } // Remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = curBlock; // Note: doesn't matter if we set mNewBlockElement multiple times. // // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it // alive. nsresult rv = MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *curBlock); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } continue; } if (HTMLEditUtils::IsInlineElement(content)) { // If content is inline, pull it into curBlock. Note: it's assumed that // consecutive inline nodes in aNodeArray are actually members of the // same block parent. This happens to be true now as a side effect of // how aNodeArray is contructed, but some additional logic should be // added here if that should change // // If content is a non editable, drop it if we are going to
. if (&aBlockTag == nsGkAtoms::pre && !EditorUtils::IsEditableContent(content, EditorType::HTML)) { // Do nothing to this block continue; } // If no curBlock, make one if (!curBlock) { SplitNodeResult splitNodeResult = MaybeSplitAncestorsForInsertWithTransaction(aBlockTag, atContent); if (splitNodeResult.Failed()) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() " "failed"); return splitNodeResult.Rv(); } // If current handling node has been moved from the container by a // mutation event listener when we need to do something more for it, // we should stop handling this action since we cannot handle each of // a lot of edge cases. if (NS_WARN_IF(atContent.HasChildMovedFromContainer())) { return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } EditorDOMPoint splitPoint = splitNodeResult.SplitPoint(); curBlock = CreateNodeWithTransaction(aBlockTag, splitPoint); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!curBlock) { NS_WARNING("EditorBase::CreateNodeWithTransaction() failed"); return NS_ERROR_FAILURE; } // If the new block element was moved to different element or removed // by the web app via mutation event listener, we should stop handling // this action since we cannot handle each of a lot of edge cases. if (NS_WARN_IF(curBlock->GetParentNode() != splitPoint.GetContainer())) { return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; } // Update container of content. atContent.Set(content); // Remember our new block for postprocessing TopLevelEditSubActionDataRef().mNewBlockElement = curBlock; // Note: doesn't matter if we set mNewBlockElement multiple times. } if (NS_WARN_IF(!atContent.IsSet())) { // This is possible due to mutation events, let's not assert return NS_ERROR_UNEXPECTED; } // XXX If content is a br, replace it with a return if going to
// This is a continuation of some inline nodes that belong together in // the same block item. Use curBlock. // // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it // alive. We could try to make that a rvalue ref and create a const array // on the stack here, but callers are passing in auto arrays, and we don't // want to introduce copies.. nsresult rv = MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *curBlock); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); return rv; } } } return NS_OK; } SplitNodeResult HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction( nsAtom& aTag, const EditorDOMPoint& aStartOfDeepestRightNode) { MOZ_ASSERT(IsEditActionDataAvailable()); if (NS_WARN_IF(!aStartOfDeepestRightNode.IsSet())) { return SplitNodeResult(NS_ERROR_INVALID_ARG); } MOZ_ASSERT(aStartOfDeepestRightNode.IsSetAndValid()); RefPtr host = GetActiveEditingHost(); if (NS_WARN_IF(!host)) { return SplitNodeResult(NS_ERROR_FAILURE); } // The point must be descendant of editing host. if (aStartOfDeepestRightNode.GetContainer() != host && !EditorUtils::IsDescendantOf(*aStartOfDeepestRightNode.GetContainer(), *host)) { NS_WARNING("aStartOfDeepestRightNode was not in editing host"); return SplitNodeResult(NS_ERROR_INVALID_ARG); } // Look for a node that can legally contain the tag. EditorDOMPoint pointToInsert(aStartOfDeepestRightNode); for (; pointToInsert.IsSet(); pointToInsert.Set(pointToInsert.GetContainer())) { // We cannot split active editing host and its ancestor. So, there is // no element to contain the specified element. if (pointToInsert.GetChild() == host) { NS_WARNING( "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() reached " "editing host"); return SplitNodeResult(NS_ERROR_FAILURE); } if (HTMLEditUtils::CanNodeContain(*pointToInsert.GetContainer(), aTag)) { // Found an ancestor node which can contain the element. break; } } MOZ_DIAGNOSTIC_ASSERT(pointToInsert.IsSet()); // If the point itself can contain the tag, we don't need to split any // ancestor nodes. In this case, we should return the given split point // as is. if (pointToInsert.GetContainer() == aStartOfDeepestRightNode.GetContainer()) { return SplitNodeResult(aStartOfDeepestRightNode); } SplitNodeResult splitNodeResult = SplitNodeDeepWithTransaction( MOZ_KnownLive(*pointToInsert.GetChild()), aStartOfDeepestRightNode, SplitAtEdges::eAllowToCreateEmptyContainer); if (NS_WARN_IF(Destroyed())) { return SplitNodeResult(NS_ERROR_EDITOR_DESTROYED); } NS_WARNING_ASSERTION(splitNodeResult.Succeeded(), "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" "eAllowToCreateEmptyContainer) failed"); return splitNodeResult; } nsresult HTMLEditor::JoinNearestEditableNodesWithTransaction( nsIContent& aNodeLeft, nsIContent& aNodeRight, EditorDOMPoint* aNewFirstChildOfRightNode) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aNewFirstChildOfRightNode); // Caller responsible for left and right node being the same type if (NS_WARN_IF(!aNodeLeft.GetParentNode())) { return NS_ERROR_FAILURE; } // If they don't have the same parent, first move the right node to after // the left one if (aNodeLeft.GetParentNode() != aNodeRight.GetParentNode()) { nsresult rv = MoveNodeWithTransaction(aNodeRight, EditorDOMPoint(&aNodeLeft)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); return rv; } } EditorDOMPoint ret(&aNodeRight, aNodeLeft.Length()); // Separate join rules for differing blocks if (HTMLEditUtils::IsAnyListElement(&aNodeLeft) || aNodeLeft.IsText()) { // For lists, merge shallow (wouldn't want to combine list items) nsresult rv = JoinNodesWithTransaction(aNodeLeft, aNodeRight); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::JoinNodesWithTransaction failed"); if (NS_SUCCEEDED(rv)) { // XXX `ret` may point invalid point if mutation event listener changed // the previous siblings... *aNewFirstChildOfRightNode = std::move(ret); } return rv; } // Remember the last left child, and first right child nsCOMPtr lastLeft = GetLastEditableChild(aNodeLeft); if (NS_WARN_IF(!lastLeft)) { return NS_ERROR_FAILURE; } nsCOMPtr firstRight = GetFirstEditableChild(aNodeRight); if (NS_WARN_IF(!firstRight)) { return NS_ERROR_FAILURE; } // For list items, divs, etc., merge smart nsresult rv = JoinNodesWithTransaction(aNodeLeft, aNodeRight); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::JoinNodesWithTransaction() failed"); return rv; } if ((lastLeft->IsText() || lastLeft->IsElement()) && HTMLEditUtils::CanContentsBeJoined(*lastLeft, *firstRight, StyleDifference::CompareIfElements)) { nsresult rv = JoinNearestEditableNodesWithTransaction( *lastLeft, *firstRight, aNewFirstChildOfRightNode); NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::JoinNearestEditableNodesWithTransaction() failed"); return rv; } // XXX `ret` may point invalid point if mutation event listener changed // the previous siblings... *aNewFirstChildOfRightNode = std::move(ret); return NS_OK; } Element* HTMLEditor::GetMostAncestorMailCiteElement(nsINode& aNode) const { Element* mailCiteElement = nullptr; bool isPlaintextEditor = IsPlaintextEditor(); for (nsINode* node = &aNode; node; node = node->GetParentNode()) { if ((isPlaintextEditor && node->IsHTMLElement(nsGkAtoms::pre)) || HTMLEditUtils::IsMailCite(node)) { mailCiteElement = node->AsElement(); } if (node->IsHTMLElement(nsGkAtoms::body)) { break; } } return mailCiteElement; } nsresult HTMLEditor::CacheInlineStyles(nsIContent& aContent) { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); nsresult rv = GetInlineStyles( aContent, *TopLevelEditSubActionDataRef().mCachedInlineStyles); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::GetInlineStyles() failed"); return rv; } nsresult HTMLEditor::GetInlineStyles(nsIContent& aContent, AutoStyleCacheArray& aStyleCacheArray) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aStyleCacheArray.IsEmpty()); bool useCSS = IsCSSEnabled(); for (nsStaticAtom* property : {nsGkAtoms::b, nsGkAtoms::i, nsGkAtoms::u, nsGkAtoms::face, nsGkAtoms::size, nsGkAtoms::color, nsGkAtoms::tt, nsGkAtoms::em, nsGkAtoms::strong, nsGkAtoms::dfn, nsGkAtoms::code, nsGkAtoms::samp, nsGkAtoms::var, nsGkAtoms::cite, nsGkAtoms::abbr, nsGkAtoms::acronym, nsGkAtoms::backgroundColor, nsGkAtoms::sub, nsGkAtoms::sup}) { nsStaticAtom *tag, *attribute; if (property == nsGkAtoms::face || property == nsGkAtoms::size || property == nsGkAtoms::color) { tag = nsGkAtoms::font; attribute = property; } else { tag = property; attribute = nullptr; } // If type-in state is set, don't intervene bool typeInSet, unused; mTypeInState->GetTypingState(typeInSet, unused, tag, attribute, nullptr); if (typeInSet) { continue; } bool isSet = false; nsString value; // Don't use nsAutoString here because it requires memcpy // at creating new StyleCache instance. // Don't use CSS for , we don't support it usefully (bug 780035) if (!useCSS || (property == nsGkAtoms::size)) { isSet = IsTextPropertySetByContent(&aContent, tag, attribute, nullptr, &value); } else { isSet = CSSEditUtils::IsComputedCSSEquivalentToHTMLInlineStyleSet( aContent, MOZ_KnownLive(tag), MOZ_KnownLive(attribute), value); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } } if (isSet) { aStyleCacheArray.AppendElement(StyleCache(tag, attribute, value)); } } return NS_OK; } nsresult HTMLEditor::ReapplyCachedStyles() { MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); // The idea here is to examine our cached list of styles and see if any have // been removed. If so, add typeinstate for them, so that they will be // reinserted when new content is added. if (TopLevelEditSubActionDataRef().mCachedInlineStyles->IsEmpty() || !SelectionRefPtr()->RangeCount()) { return NS_OK; } // remember if we are in css mode bool useCSS = IsCSSEnabled(); const RangeBoundary& atStartOfSelection = SelectionRefPtr()->GetRangeAt(0)->StartRef(); nsCOMPtr startContainerContent = atStartOfSelection.Container() && atStartOfSelection.Container()->IsContent() ? atStartOfSelection.Container()->AsContent() : nullptr; if (NS_WARN_IF(!startContainerContent)) { return NS_OK; } AutoStyleCacheArray styleCacheArrayAtInsertionPoint; nsresult rv = GetInlineStyles(*startContainerContent, styleCacheArrayAtInsertionPoint); if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::GetInlineStyles() failed, but ignored"); return NS_OK; } for (StyleCache& styleCacheBeforeEdit : *TopLevelEditSubActionDataRef().mCachedInlineStyles) { bool isFirst = false, isAny = false, isAll = false; nsAutoString currentValue; if (useCSS) { // check computed style first in css case isAny = CSSEditUtils::IsComputedCSSEquivalentToHTMLInlineStyleSet( *startContainerContent, MOZ_KnownLive(styleCacheBeforeEdit.Tag()), MOZ_KnownLive(styleCacheBeforeEdit.GetAttribute()), currentValue); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } } if (!isAny) { // then check typeinstate and html style nsresult rv = GetInlinePropertyBase( MOZ_KnownLive(*styleCacheBeforeEdit.Tag()), MOZ_KnownLive(styleCacheBeforeEdit.GetAttribute()), &styleCacheBeforeEdit.Value(), &isFirst, &isAny, &isAll, ¤tValue); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::GetInlinePropertyBase() failed"); return rv; } } // This style has disappeared through deletion. Let's add the styles to // mTypeInState when same style isn't applied to the node already. if (isAny && !IsStyleCachePreservingSubAction(GetTopLevelEditSubAction())) { continue; } AutoStyleCacheArray::index_type index = styleCacheArrayAtInsertionPoint.IndexOf( styleCacheBeforeEdit.Tag(), styleCacheBeforeEdit.GetAttribute()); if (index == AutoStyleCacheArray::NoIndex || styleCacheBeforeEdit.Value() != styleCacheArrayAtInsertionPoint.ElementAt(index).Value()) { mTypeInState->SetProp(styleCacheBeforeEdit.Tag(), styleCacheBeforeEdit.GetAttribute(), styleCacheBeforeEdit.Value()); } } return NS_OK; } nsresult HTMLEditor::InsertBRElementToEmptyListItemsAndTableCellsInRange( const RawRangeBoundary& aStartRef, const RawRangeBoundary& aEndRef) { MOZ_ASSERT(IsEditActionDataAvailable()); AutoTArray, 64> arrayOfEmptyElements; DOMIterator iter; if (NS_FAILED(iter.Init(aStartRef, aEndRef))) { NS_WARNING("DOMIterator::Init() failed"); return NS_ERROR_FAILURE; } iter.AppendNodesToArray( +[](nsINode& aNode, void* aSelf) { MOZ_ASSERT(Element::FromNode(&aNode)); MOZ_ASSERT(aSelf); Element* element = aNode.AsElement(); if (!EditorUtils::IsEditableContent(*element, EditorType::HTML) || (!HTMLEditUtils::IsListItem(element) && !HTMLEditUtils::IsTableCellOrCaption(*element))) { return false; } return static_cast(aSelf)->IsEmptyNode(*element, false, false); }, arrayOfEmptyElements, this); // Put padding
elements for empty
and
,
. for (auto& emptyElement : arrayOfEmptyElements) { // Need to put br at END of node. It may have empty containers in it and // still pass the "IsEmptyNode" test, and we want the br's to be after // them. Also, we want the br to be after the selection if the selection // is in this node. EditorDOMPoint endOfNode(EditorDOMPoint::AtEndOf(emptyElement)); CreateElementResult createPaddingBRResult = InsertPaddingBRElementForEmptyLastLineWithTransaction(endOfNode); if (createPaddingBRResult.Failed()) { NS_WARNING( "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction() " "failed"); return createPaddingBRResult.Rv(); } } return NS_OK; } nsresult HTMLEditor::EnsureCaretInBlockElement(Element& aElement) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(SelectionRefPtr()->IsCollapsed()); EditorRawDOMPoint atCaret(EditorBase::GetStartPoint(*SelectionRefPtr())); if (NS_WARN_IF(!atCaret.IsSet())) { return NS_ERROR_FAILURE; } // Use ranges and RangeUtils::CompareNodeToRange() to compare selection // start to new block. RefPtr staticRange = StaticRange::Create(atCaret.ToRawRangeBoundary(), atCaret.ToRawRangeBoundary(), IgnoreErrors()); if (!staticRange) { NS_WARNING("StaticRange::Create() failed"); return NS_ERROR_FAILURE; } bool nodeBefore, nodeAfter; nsresult rv = RangeUtils::CompareNodeToRange(&aElement, staticRange, &nodeBefore, &nodeAfter); if (NS_FAILED(rv)) { NS_WARNING("RangeUtils::CompareNodeToRange() failed"); return rv; } if (nodeBefore && nodeAfter) { return NS_OK; // selection is inside block } if (nodeBefore) { // selection is after block. put at end of block. nsIContent* lastEditableContent = GetLastEditableChild(aElement); if (!lastEditableContent) { lastEditableContent = &aElement; } EditorRawDOMPoint endPoint; if (lastEditableContent->IsText() || HTMLEditUtils::IsContainerNode(*lastEditableContent)) { endPoint.SetToEndOf(lastEditableContent); } else { endPoint.SetAfter(lastEditableContent); if (NS_WARN_IF(!endPoint.IsSet())) { return NS_ERROR_FAILURE; } } nsresult rv = CollapseSelectionTo(endPoint); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } // selection is before block. put at start of block. nsIContent* firstEditableContent = GetFirstEditableChild(aElement); if (!firstEditableContent) { firstEditableContent = &aElement; } EditorRawDOMPoint atStartOfBlock; if (firstEditableContent->IsText() || HTMLEditUtils::IsContainerNode(*firstEditableContent)) { atStartOfBlock.Set(firstEditableContent); } else { atStartOfBlock.Set(firstEditableContent, 0); } rv = CollapseSelectionTo(atStartOfBlock); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } void HTMLEditor::SetSelectionInterlinePosition() { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(SelectionRefPtr()->IsCollapsed()); // Get the (collapsed) selection location const nsRange* firstRange = SelectionRefPtr()->GetRangeAt(0); if (NS_WARN_IF(!firstRange)) { return; } EditorDOMPoint atCaret(firstRange->StartRef()); if (NS_WARN_IF(!atCaret.IsSet())) { return; } MOZ_ASSERT(atCaret.IsSetAndValid()); // First, let's check to see if we are after a `
`. We take care of this // special-case first so that we don't accidentally fall through into one of // the other conditionals. // XXX Although I don't understand "interline position", if caret is // immediately after non-editable contents, but previous editable // content is `
`, does this do right thing? if (nsIContent* previousEditableContentInBlock = GetPreviousEditableHTMLNodeInBlock(atCaret)) { if (previousEditableContentInBlock->IsHTMLElement(nsGkAtoms::br)) { IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition(true, ignoredError); NS_WARNING_ASSERTION( !ignoredError.Failed(), "Selection::SetInterlinePosition(true) failed, but ignored"); return; } } if (!atCaret.GetChild()) { return; } // If caret is immediately after a block, set interline position to "right". // XXX Although I don't understand "interline position", if caret is // immediately after non-editable contents, but previous editable // content is a block, does this do right thing? if (nsIContent* previousEditableContentInBlockAtCaret = GetPriorHTMLSibling(atCaret.GetChild())) { if (HTMLEditUtils::IsBlockElement(*previousEditableContentInBlockAtCaret)) { IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition(true, ignoredError); NS_WARNING_ASSERTION( !ignoredError.Failed(), "Selection::SetInterlinePosition(true) failed, but ignored"); return; } } // If caret is immediately before a block, set interline position to "left". // XXX Although I don't understand "interline position", if caret is // immediately before non-editable contents, but next editable // content is a block, does this do right thing? if (nsIContent* nextEditableContentInBlockAtCaret = GetNextHTMLSibling(atCaret.GetChild())) { if (HTMLEditUtils::IsBlockElement(*nextEditableContentInBlockAtCaret)) { IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition(false, ignoredError); NS_WARNING_ASSERTION( !ignoredError.Failed(), "Selection::SetInterlinePosition(false) failed, but ignored"); } } } nsresult HTMLEditor::AdjustCaretPositionAndEnsurePaddingBRElement( nsIEditor::EDirection aDirectionAndAmount) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(SelectionRefPtr()->IsCollapsed()); EditorDOMPoint point(EditorBase::GetStartPoint(*SelectionRefPtr())); if (NS_WARN_IF(!point.IsInContentNode())) { return NS_ERROR_FAILURE; } // If selection start is not editable, climb up the tree until editable one. while (!EditorUtils::IsEditableContent(*point.ContainerAsContent(), EditorType::HTML)) { point.Set(point.GetContainer()); if (NS_WARN_IF(!point.IsInContentNode())) { return NS_ERROR_FAILURE; } } // If caret is in empty block element, we need to insert a `
` element // because the block should have one-line height. if (RefPtr blockElement = HTMLEditUtils::GetInclusiveAncestorBlockElement( *point.ContainerAsContent())) { if (blockElement && EditorUtils::IsEditableContent(*blockElement, EditorType::HTML) && IsEmptyNode(*blockElement, false, false) && HTMLEditUtils::CanNodeContain(*point.GetContainer(), *nsGkAtoms::br)) { Element* bodyOrDocumentElement = GetRoot(); if (NS_WARN_IF(!bodyOrDocumentElement)) { return NS_ERROR_FAILURE; } if (point.GetContainer() == bodyOrDocumentElement) { // Our root node is completely empty. Don't add a
here. // AfterEditInner() will add one for us when it calls // TextEditor::MaybeCreatePaddingBRElementForEmptyEditor(). // XXX This kind of dependency between methods makes us spaghetti. // Let's handle it here later. // XXX This looks odd check. If active editing host is not a // ``, what are we doing? return NS_OK; } CreateElementResult createPaddingBRResult = InsertPaddingBRElementForEmptyLastLineWithTransaction(point); NS_WARNING_ASSERTION( createPaddingBRResult.Succeeded(), "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction() " "failed"); return createPaddingBRResult.Rv(); } } // XXX Perhaps, we should do something if we're in a data node but not // a text node. if (point.IsInTextNode()) { return NS_OK; } // Do we need to insert a padding
element for empty last line? We do // if we are: // 1) prior node is in same block where selection is AND // 2) prior node is a br AND // 3) that br is not visible if (nsCOMPtr previousEditableContent = GetPreviousEditableHTMLNode(point)) { RefPtr blockElementAtCaret = HTMLEditUtils::GetInclusiveAncestorBlockElement( *point.ContainerAsContent()); RefPtr blockElementParentAtPreviousEditableContent = HTMLEditUtils::GetAncestorBlockElement(*previousEditableContent); // If previous editable content of caret is in same block and a `
` // element, we need to adjust interline position. if (blockElementAtCaret && blockElementAtCaret == blockElementParentAtPreviousEditableContent && previousEditableContent && previousEditableContent->IsHTMLElement(nsGkAtoms::br)) { // If it's an invisible `
` element, we need to insert a padding // `
` element for making empty line have one-line height. if (!IsVisibleBRElement(previousEditableContent)) { CreateElementResult createPaddingBRResult = InsertPaddingBRElementForEmptyLastLineWithTransaction(point); if (createPaddingBRResult.Failed()) { NS_WARNING( "HTMLEditor::" "InsertPaddingBRElementForEmptyLastLineWithTransaction() failed"); return createPaddingBRResult.Rv(); } point.Set(createPaddingBRResult.GetNewNode()); // Selection stays *before* padding `
` element for empty last // line, sticking to it. IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition(true, ignoredError); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( !ignoredError.Failed(), "Selection::SetInterlinePosition(true) failed, but ignored"); nsresult rv = CollapseSelectionTo(point); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::CollapseSelectionTo() failed"); return rv; } } // If it's a visible `
` element and next editable content is a // padding `
` element, we need to set interline position. else if (nsIContent* nextEditableContentInBlock = GetNextEditableHTMLNodeInBlock(*previousEditableContent)) { if (EditorUtils::IsPaddingBRElementForEmptyLastLine( *nextEditableContentInBlock)) { // Make it stick to the padding `
` element so that it will be // on blank line. IgnoredErrorResult ignoredError; SelectionRefPtr()->SetInterlinePosition(true, ignoredError); NS_WARNING_ASSERTION( !ignoredError.Failed(), "Selection::SetInterlinePosition(true) failed, but ignored"); } } } } // If previous editable content in same block is `
`, text node, `` // or `
`, current caret position is fine. if (nsIContent* previousEditableContentInBlock = GetPreviousEditableHTMLNodeInBlock(point)) { if (previousEditableContentInBlock->IsHTMLElement(nsGkAtoms::br) || previousEditableContentInBlock->IsText() || HTMLEditUtils::IsImage(previousEditableContentInBlock) || previousEditableContentInBlock->IsHTMLElement(nsGkAtoms::hr)) { return NS_OK; } } // If next editable content in same block is `
`, text node, `` or // `
`, current caret position is fine. if (nsIContent* nextEditableContentInBlock = GetNextEditableHTMLNodeInBlock(point)) { if (nextEditableContentInBlock->IsText() || nextEditableContentInBlock->IsAnyOfHTMLElements( nsGkAtoms::br, nsGkAtoms::img, nsGkAtoms::hr)) { return NS_OK; } } // Otherwise, look for a near editable content towards edit action direction. // If there is no editable content, keep current caret position. nsIContent* nearEditableContent = FindNearEditableContent(point, aDirectionAndAmount); if (!nearEditableContent) { return NS_OK; } EditorDOMPoint pointToPutCaret = GetGoodCaretPointFor(*nearEditableContent, aDirectionAndAmount); if (!pointToPutCaret.IsSet()) { NS_WARNING("HTMLEditor::GetGoodCaretPointFor() failed"); return NS_ERROR_FAILURE; } nsresult rv = CollapseSelectionTo(pointToPutCaret); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::CollapseSelectionTo() failed"); return rv; } template nsIContent* HTMLEditor::FindNearEditableContent( const EditorDOMPointBase& aPoint, nsIEditor::EDirection aDirection) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aPoint.IsSetAndValid()); nsIContent* editableContent = nullptr; if (aDirection == nsIEditor::ePrevious) { editableContent = GetPreviousEditableHTMLNode(aPoint); if (!editableContent) { return nullptr; // Not illegal. } } else { editableContent = GetNextEditableHTMLNode(aPoint); if (NS_WARN_IF(!editableContent)) { // Perhaps, illegal because the node pointed by aPoint isn't editable // and nobody of previous nodes is editable. return nullptr; } } // scan in the right direction until we find an eligible text node, // but don't cross any breaks, images, or table elements. // XXX This comment sounds odd. editableContent may have already crossed // breaks and/or images if they are non-editable. while (editableContent && !editableContent->IsText() && !editableContent->IsHTMLElement(nsGkAtoms::br) && !HTMLEditUtils::IsImage(editableContent)) { if (aDirection == nsIEditor::ePrevious) { editableContent = GetPreviousEditableHTMLNode(*editableContent); if (NS_WARN_IF(!editableContent)) { return nullptr; } } else { editableContent = GetNextEditableHTMLNode(*editableContent); if (NS_WARN_IF(!editableContent)) { return nullptr; } } } // don't cross any table elements if (HTMLEditor::NodesInDifferentTableElements(*editableContent, *aPoint.GetContainer())) { return nullptr; } // otherwise, ok, we have found a good spot to put the selection return editableContent; } // static bool HTMLEditor::NodesInDifferentTableElements(nsINode& aNode1, nsINode& aNode2) { nsINode* parentNode1; for (parentNode1 = &aNode1; parentNode1 && !HTMLEditUtils::IsAnyTableElement(parentNode1); parentNode1 = parentNode1->GetParentNode()) { } nsINode* parentNode2; for (parentNode2 = &aNode2; parentNode2 && !HTMLEditUtils::IsAnyTableElement(parentNode2); parentNode2 = parentNode2->GetParentNode()) { } // XXX Despite of the name, this returns true if only one node is in a // table related element. return parentNode1 != parentNode2; } nsresult HTMLEditor::RemoveEmptyNodesIn(nsRange& aRange) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(aRange.IsPositioned()); // Some general notes on the algorithm used here: the goal is to examine all // the nodes in aRange, and remove the empty ones. We do this by // using a content iterator to traverse all the nodes in the range, and // placing the empty nodes into an array. After finishing the iteration, // we delete the empty nodes in the array. (They cannot be deleted as we // find them because that would invalidate the iterator.) // // Since checking to see if a node is empty can be costly for nodes with // many descendants, there are some optimizations made. I rely on the fact // that the iterator is post-order: it will visit children of a node before // visiting the parent node. So if I find that a child node is not empty, I // know that its parent is not empty without even checking. So I put the // parent on a "skipList" which is just a voidArray of nodes I can skip the // empty check on. If I encounter a node on the skiplist, i skip the // processing for that node and replace its slot in the skiplist with that // node's parent. // // An interesting idea is to go ahead and regard parent nodes that are NOT // on the skiplist as being empty (without even doing the IsEmptyNode check) // on the theory that if they weren't empty, we would have encountered a // non-empty child earlier and thus put this parent node on the skiplist. // // Unfortunately I can't use that strategy here, because the range may // include some children of a node while excluding others. Thus I could // find all the _examined_ children empty, but still not have an empty // parent. PostContentIterator postOrderIter; nsresult rv = postOrderIter.Init(&aRange); if (NS_FAILED(rv)) { NS_WARNING("PostContentIterator::Init() failed"); return rv; } AutoTArray, 64> arrayOfEmptyContents, arrayOfEmptyCites, skipList; // Check for empty nodes for (; !postOrderIter.IsDone(); postOrderIter.Next()) { MOZ_ASSERT(postOrderIter.GetCurrentNode()->IsContent()); nsIContent* content = postOrderIter.GetCurrentNode()->AsContent(); nsIContent* parentContent = content->GetParent(); size_t idx = skipList.IndexOf(content); if (idx != skipList.NoIndex) { // This node is on our skip list. Skip processing for this node, and // replace its value in the skip list with the value of its parent if (parentContent) { skipList[idx] = parentContent; } continue; } bool isCandidate = false; bool isMailCite = false; if (content->IsElement()) { if (content->IsHTMLElement(nsGkAtoms::body)) { // Don't delete the body } else if ((isMailCite = HTMLEditUtils::IsMailCite(content)) || content->IsHTMLElement(nsGkAtoms::a) || HTMLEditUtils::IsInlineStyle(content) || HTMLEditUtils::IsAnyListElement(content) || content->IsHTMLElement(nsGkAtoms::div)) { // Only consider certain nodes to be empty for purposes of removal isCandidate = true; } else if (HTMLEditUtils::IsFormatNode(content) || HTMLEditUtils::IsListItem(content) || content->IsHTMLElement(nsGkAtoms::blockquote)) { // These node types are candidates if selection is not in them. If // it is one of these, don't delete if selection inside. This is so // we can create empty headings, etc., for the user to type into. isCandidate = !StartOrEndOfSelectionRangesIsIn(*content); } } bool isEmptyNode = false; if (isCandidate) { // We delete mailcites even if they have a solo br in them. Other // nodes we require to be empty. isEmptyNode = IsEmptyNode(*content, isMailCite, true); if (isEmptyNode) { if (isMailCite) { // mailcites go on a separate list from other empty nodes arrayOfEmptyCites.AppendElement(*content); } else { arrayOfEmptyContents.AppendElement(*content); } } } if (!isEmptyNode && parentContent) { // put parent on skip list skipList.AppendElement(*parentContent); } } // now delete the empty nodes for (OwningNonNull& emptyContent : arrayOfEmptyContents) { // XXX Shouldn't we check whether it's removable from its parent?? if (HTMLEditUtils::IsSimplyEditableNode(emptyContent)) { // MOZ_KnownLive because 'arrayOfEmptyContents' is guaranteed to keep it // alive. rv = DeleteNodeWithTransaction(MOZ_KnownLive(emptyContent)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } } } // Now delete the empty mailcites. This is a separate step because we want // to pull out any br's and preserve them. for (OwningNonNull& emptyCite : arrayOfEmptyCites) { if (!IsEmptyNode(emptyCite, false, true)) { // We are deleting a cite that has just a `
`. We want to delete cite, // but preserve `
`. RefPtr brElement = InsertBRElementWithTransaction(EditorDOMPoint(emptyCite)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (!brElement) { NS_WARNING("HTMLEditor::InsertBRElementWithTransaction() failed"); return NS_ERROR_FAILURE; } } // MOZ_KnownLive because 'arrayOfEmptyCites' is guaranteed to keep it alive. rv = DeleteNodeWithTransaction(MOZ_KnownLive(emptyCite)); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); return rv; } } return NS_OK; } bool HTMLEditor::StartOrEndOfSelectionRangesIsIn(nsIContent& aContent) const { MOZ_ASSERT(IsEditActionDataAvailable()); for (uint32_t i = 0; i < SelectionRefPtr()->RangeCount(); ++i) { const nsRange* range = SelectionRefPtr()->GetRangeAt(i); nsINode* startContainer = range->GetStartContainer(); if (startContainer) { if (&aContent == startContainer) { return true; } if (EditorUtils::IsDescendantOf(*startContainer, aContent)) { return true; } } nsINode* endContainer = range->GetEndContainer(); if (startContainer == endContainer) { continue; } if (endContainer) { if (&aContent == endContainer) { return true; } if (EditorUtils::IsDescendantOf(*endContainer, aContent)) { return true; } } } return false; } nsresult HTMLEditor::LiftUpListItemElement( Element& aListItemElement, LiftUpFromAllParentListElements aLiftUpFromAllParentListElements) { MOZ_ASSERT(IsEditActionDataAvailable()); if (!HTMLEditUtils::IsListItem(&aListItemElement)) { return NS_ERROR_INVALID_ARG; } if (NS_WARN_IF(!aListItemElement.GetParentElement()) || NS_WARN_IF(!aListItemElement.GetParentElement()->GetParentNode())) { return NS_ERROR_FAILURE; } // if it's first or last list item, don't need to split the list // otherwise we do. bool isFirstListItem = IsFirstEditableChild(&aListItemElement); bool isLastListItem = IsLastEditableChild(&aListItemElement); Element* leftListElement = aListItemElement.GetParentElement(); if (NS_WARN_IF(!leftListElement)) { return NS_ERROR_FAILURE; } // If it's at middle of parent list element, split the parent list element. // Then, aListItem becomes the first list item of the right list element. if (!isFirstListItem && !isLastListItem) { EditorDOMPoint atListItemElement(&aListItemElement); if (NS_WARN_IF(!atListItemElement.IsSet())) { return NS_ERROR_FAILURE; } MOZ_ASSERT(atListItemElement.IsSetAndValid()); ErrorResult error; nsCOMPtr maybeLeftListContent = SplitNodeWithTransaction(atListItemElement, error); if (NS_WARN_IF(Destroyed())) { error = NS_ERROR_EDITOR_DESTROYED; } if (error.Failed()) { NS_WARNING_ASSERTION(error.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED), "HTMLEditor::SplitNodeWithTransaction() failed"); return error.StealNSResult(); } if (!maybeLeftListContent->IsElement()) { NS_WARNING( "HTMLEditor::SplitNodeWithTransaction() didn't return left list " "element"); return NS_ERROR_FAILURE; } leftListElement = maybeLeftListContent->AsElement(); } // In most cases, insert the list item into the new left list node.. EditorDOMPoint pointToInsertListItem(leftListElement); if (NS_WARN_IF(!pointToInsertListItem.IsSet())) { return NS_ERROR_FAILURE; } // But when the list item was the first child of the right list, it should // be inserted between the both list elements. This allows user to hit // Enter twice at a list item breaks the parent list node. if (!isFirstListItem) { DebugOnly advanced = pointToInsertListItem.AdvanceOffset(); NS_WARNING_ASSERTION(advanced, "Failed to advance offset to right list node"); } nsresult rv = MoveNodeWithTransaction(aListItemElement, pointToInsertListItem); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); return rv; } // Unwrap list item contents if they are no longer in a list // XXX If the parent list element is a child of another list element // (although invalid tree), the list item element won't be unwrapped. // That makes the parent ancestor element tree valid, but might be // unexpected result. // XXX If aListItemElement is
or
and current parent is
or
, // the list items won't be unwrapped. If aListItemElement is
and its // current parent is
, there is same issue. if (!HTMLEditUtils::IsAnyListElement(pointToInsertListItem.GetContainer()) && HTMLEditUtils::IsListItem(&aListItemElement)) { nsresult rv = RemoveBlockContainerWithTransaction(aListItemElement); if (NS_WARN_IF(Destroyed())) { return NS_ERROR_EDITOR_DESTROYED; } NS_WARNING_ASSERTION( NS_SUCCEEDED(rv), "HTMLEditor::RemoveBlockContainerWithTransaction() failed"); return rv; } if (aLiftUpFromAllParentListElements == LiftUpFromAllParentListElements::No) { return NS_OK; } // XXX If aListItemElement is moved to unexpected element by mutation event // listener, shouldn't we stop calling this? rv = LiftUpListItemElement(aListItemElement, LiftUpFromAllParentListElements::Yes); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::LiftUpListItemElement(" "LiftUpFromAllParentListElements::Yes) failed"); return rv; } nsresult HTMLEditor::DestroyListStructureRecursively(Element& aListElement) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement)); // XXX If mutation event listener inserts new child into `aListElement`, // this becomes infinite loop so that we should set limit of the // loop count from original child count. while (aListElement.GetFirstChild()) { OwningNonNull child = *aListElement.GetFirstChild(); if (HTMLEditUtils::IsListItem(child)) { // XXX Using LiftUpListItemElement() is too expensive for this purpose. // Looks like the reason why this method uses it is, only this loop // wants to work with first child of aListElement. However, what it // actually does is removing
as container. Perhaps, we should // decide destination first, and then, move contents in `child`. // XXX If aListElement is is a child of another list element (although // it's invalid tree), this moves the list item to outside of // aListElement's parent. Is that really intentional behavior? nsresult rv = LiftUpListItemElement( MOZ_KnownLive(*child->AsElement()), HTMLEditor::LiftUpFromAllParentListElements::Yes); if (NS_FAILED(rv)) { NS_WARNING( "HTMLEditor::LiftUpListItemElement(LiftUpFromAllParentListElements:" ":Yes) failed"); return rv; } continue; } if (HTMLEditUtils::IsAnyListElement(child)) { nsresult rv = DestroyListStructureRecursively(MOZ_KnownLive(*child->AsElement())); if (NS_FAILED(rv)) { NS_WARNING("HTMLEditor::DestroyListStructureRecursively() failed"); return rv; } continue; } // Delete any non-list items for now // XXX This is not HTML5 aware. HTML5 allows all list elements to have //