` elements + // if aHTMLEditor is not in CSS mode. + + if (NS_WARN_IF(!aHTMLEditor.GetRoot())) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + OwningNonNull bodyOrDocumentElement = *aHTMLEditor.GetRoot(); + EditorRawDOMPoint atBodyOrDocumentElement(bodyOrDocumentElement); + + const nsRange* firstRange = aHTMLEditor.SelectionRef().GetRangeAt(0); + mFoundSelectionRanges = !!firstRange; + if (!mFoundSelectionRanges) { + NS_WARNING("There was no selection range"); + aRv.Throw(NS_ERROR_FAILURE); + return; + } + EditorRawDOMPoint atStartOfSelection(firstRange->StartRef()); + if (NS_WARN_IF(!atStartOfSelection.IsSet())) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + MOZ_ASSERT(atStartOfSelection.IsSetAndValid()); + + nsIContent* editTargetContent = nullptr; + // If selection is collapsed or in a text node, take the container. + if (aHTMLEditor.SelectionRef().IsCollapsed() || + atStartOfSelection.IsInTextNode()) { + editTargetContent = atStartOfSelection.GetContainerAs(); + if (NS_WARN_IF(!editTargetContent)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + } + // If selection container is the `` element which is set to + // `HTMLDocument.body`, take first editable node in it. + // XXX Why don't we just compare `atStartOfSelection.GetChild()` and + // `bodyOrDocumentElement`? Then, we can avoid computing the + // offset. + else if (atStartOfSelection.IsContainerHTMLElement(nsGkAtoms::html) && + atBodyOrDocumentElement.IsSet() && + atStartOfSelection.Offset() == atBodyOrDocumentElement.Offset()) { + editTargetContent = HTMLEditUtils::GetNextContent( + atStartOfSelection, {WalkTreeOption::IgnoreNonEditableNode}, + aHTMLEditor.ComputeEditingHost()); + if (NS_WARN_IF(!editTargetContent)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + } + // Otherwise, use first selected node. + // XXX Only for retreiving it, the following block treats all selected + // ranges. `HTMLEditor` should have + // `GetFirstSelectionRangeExtendedToHardLineStartAndEnd()`. + else { + Element* editingHostOrRoot = aHTMLEditor.ComputeEditingHost(); + if (!editingHostOrRoot) { + // This is not a handler of editing command so that if there is no active + // editing host, let's use the or document element instead. + editingHostOrRoot = aHTMLEditor.GetRoot(); + if (!editingHostOrRoot) { + return; + } + } + AutoRangeArray extendedSelectionRanges(aHTMLEditor.SelectionRef()); + extendedSelectionRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eSetOrClearAlignment, *editingHostOrRoot); + + AutoTArray, 64> arrayOfContents; + nsresult rv = extendedSelectionRanges.CollectEditTargetNodes( + aHTMLEditor, arrayOfContents, EditSubAction::eSetOrClearAlignment, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(eSetOrClearAlignment, " + "CollectNonEditableNodes::Yes) failed"); + aRv.Throw(NS_ERROR_FAILURE); + return; + } + if (arrayOfContents.IsEmpty()) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(eSetOrClearAlignment, " + "CollectNonEditableNodes::Yes) returned no contents"); + aRv.Throw(NS_ERROR_FAILURE); + return; + } + editTargetContent = arrayOfContents[0]; + } + + const RefPtr maybeNonEditableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *editTargetContent, HTMLEditUtils::ClosestBlockElement); + if (NS_WARN_IF(!maybeNonEditableBlockElement)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + if (aHTMLEditor.IsCSSEnabled() && EditorElementStyle::Align().IsCSSEditable( + *maybeNonEditableBlockElement)) { + // We are in CSS mode and we know how to align this element with CSS + nsAutoString value; + // Let's get the value(s) of text-align or margin-left/margin-right + DebugOnly rvIgnored = CSSEditUtils::GetComputedCSSEquivalentTo( + *maybeNonEditableBlockElement, EditorElementStyle::Align(), value); + if (NS_WARN_IF(aHTMLEditor.Destroyed())) { + aRv.Throw(NS_ERROR_EDITOR_DESTROYED); + return; + } + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "CSSEditUtils::GetComputedCSSEquivalentTo(" + "EditorElementStyle::Align()) failed, but ignored"); + if (value.EqualsLiteral(u"center") || value.EqualsLiteral(u"-moz-center") || + value.EqualsLiteral(u"auto auto")) { + mFirstAlign = nsIHTMLEditor::eCenter; + return; + } + if (value.EqualsLiteral(u"right") || value.EqualsLiteral(u"-moz-right") || + value.EqualsLiteral(u"auto 0px")) { + mFirstAlign = nsIHTMLEditor::eRight; + return; + } + if (value.EqualsLiteral(u"justify")) { + mFirstAlign = nsIHTMLEditor::eJustify; + return; + } + // XXX In RTL document, is this expected? + mFirstAlign = nsIHTMLEditor::eLeft; + return; + } + + for (Element* const containerElement : + editTargetContent->InclusiveAncestorsOfType()) { + // If the node is a parent `` element of edit target, let's break + // here to materialize the 'inline-block' behaviour of html tables + // regarding to text alignment. + if (containerElement != editTargetContent && + containerElement->IsHTMLElement(nsGkAtoms::table)) { + return; + } + + if (EditorElementStyle::Align().IsCSSEditable(*containerElement)) { + nsAutoString value; + DebugOnly rvIgnored = CSSEditUtils::GetSpecifiedProperty( + *containerElement, *nsGkAtoms::textAlign, value); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "CSSEditUtils::GetSpecifiedProperty(nsGkAtoms::" + "textAlign) failed, but ignored"); + if (!value.IsEmpty()) { + if (value.EqualsLiteral("center")) { + mFirstAlign = nsIHTMLEditor::eCenter; + return; + } + if (value.EqualsLiteral("right")) { + mFirstAlign = nsIHTMLEditor::eRight; + return; + } + if (value.EqualsLiteral("justify")) { + mFirstAlign = nsIHTMLEditor::eJustify; + return; + } + if (value.EqualsLiteral("left")) { + mFirstAlign = nsIHTMLEditor::eLeft; + return; + } + // XXX + // text-align: start and end aren't supported yet + } + } + + if (!HTMLEditUtils::SupportsAlignAttr(*containerElement)) { + continue; + } + + nsAutoString alignAttributeValue; + containerElement->GetAttr(kNameSpaceID_None, nsGkAtoms::align, + alignAttributeValue); + if (alignAttributeValue.IsEmpty()) { + continue; + } + + if (alignAttributeValue.LowerCaseEqualsASCII("center")) { + mFirstAlign = nsIHTMLEditor::eCenter; + return; + } + if (alignAttributeValue.LowerCaseEqualsASCII("right")) { + mFirstAlign = nsIHTMLEditor::eRight; + return; + } + // XXX This is odd case. `

` is not in any standards. + if (alignAttributeValue.LowerCaseEqualsASCII("justify")) { + mFirstAlign = nsIHTMLEditor::eJustify; + return; + } + // XXX In RTL document, is this expected? + mFirstAlign = nsIHTMLEditor::eLeft; + return; + } +} + +/***************************************************************************** + * ParagraphStateAtSelection + ****************************************************************************/ + +ParagraphStateAtSelection::ParagraphStateAtSelection(HTMLEditor& aHTMLEditor, + ErrorResult& aRv) { + if (NS_WARN_IF(aHTMLEditor.Destroyed())) { + aRv = EditorBase::ToGenericNSResult(NS_ERROR_EDITOR_DESTROYED); + return; + } + + // XXX Should we create another constructor which won't create + // AutoEditActionDataSetter? Or should we create another + // AutoEditActionDataSetter which won't nest edit action? + EditorBase::AutoEditActionDataSetter editActionData(aHTMLEditor, + EditAction::eNotEditing); + if (NS_WARN_IF(!editActionData.CanHandle())) { + aRv = EditorBase::ToGenericNSResult(NS_ERROR_EDITOR_DESTROYED); + return; + } + + if (aHTMLEditor.IsSelectionRangeContainerNotContent()) { + NS_WARNING("Some selection containers are not content node, but ignored"); + return; + } + + Element* editingHostOrRoot = aHTMLEditor.ComputeEditingHost(); + if (!editingHostOrRoot) { + // This is not a handler of editing command so that if there is no active + // editing host, let's use the or document element instead. + editingHostOrRoot = aHTMLEditor.GetRoot(); + if (!editingHostOrRoot) { + return; + } + } + + AutoTArray, 64> arrayOfContents; + nsresult rv = CollectEditableFormatNodesInSelection( + aHTMLEditor, *editingHostOrRoot, arrayOfContents); + if (NS_FAILED(rv)) { + NS_WARNING( + "ParagraphStateAtSelection::CollectEditableFormatNodesInSelection() " + "failed"); + aRv.Throw(rv); + return; + } + + // We need to append descendant format block if block nodes are not format + // block. This is so we only have to look "up" the hierarchy to find + // format nodes, instead of both up and down. + for (int32_t i = arrayOfContents.Length() - 1; i >= 0; i--) { + auto& content = arrayOfContents[i]; + nsAutoString format; + if (HTMLEditUtils::IsBlockElement(content) && + !HTMLEditUtils::IsFormatNode(content)) { + // XXX This RemoveObject() call has already been commented out and + // the above comment explained we're trying to replace non-format + // block nodes in the array. According to the following blocks and + // `AppendDescendantFormatNodesAndFirstInlineNode()`, replacing + // non-format block with descendants format blocks makes sense. + // arrayOfContents.RemoveObject(node); + ParagraphStateAtSelection::AppendDescendantFormatNodesAndFirstInlineNode( + arrayOfContents, *content->AsElement()); + } + } + + // We might have an empty node list. if so, find selection parent + // and put that on the list + if (arrayOfContents.IsEmpty()) { + const auto atCaret = + aHTMLEditor.GetFirstSelectionStartPoint(); + if (NS_WARN_IF(!atCaret.IsInContentNode())) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + arrayOfContents.AppendElement(*atCaret.ContainerAs()); + } + + dom::Element* bodyOrDocumentElement = aHTMLEditor.GetRoot(); + if (NS_WARN_IF(!bodyOrDocumentElement)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + for (auto& content : Reversed(arrayOfContents)) { + nsAtom* paragraphStateOfNode = nsGkAtoms::_empty; + if (HTMLEditUtils::IsFormatNode(content)) { + MOZ_ASSERT(content->NodeInfo()->NameAtom()); + paragraphStateOfNode = content->NodeInfo()->NameAtom(); + } + // Ignore non-format block node since its children have been appended + // the list above so that we'll handle this descendants later. + else if (HTMLEditUtils::IsBlockElement(content)) { + continue; + } + // If we meet an inline node, let's get its parent format. + else { + for (nsINode* parentNode = content->GetParentNode(); parentNode; + parentNode = parentNode->GetParentNode()) { + // If we reach `HTMLDocument.body` or `Document.documentElement`, + // there is no format. + if (parentNode == bodyOrDocumentElement) { + break; + } + if (HTMLEditUtils::IsFormatNode(parentNode)) { + MOZ_ASSERT(parentNode->NodeInfo()->NameAtom()); + paragraphStateOfNode = parentNode->NodeInfo()->NameAtom(); + break; + } + } + } + + // if this is the first node, we've found, remember it as the format + if (!mFirstParagraphState) { + mFirstParagraphState = paragraphStateOfNode; + continue; + } + // else make sure it matches previously found format + if (mFirstParagraphState != paragraphStateOfNode) { + mIsMixed = true; + break; + } + } +} + +// static +void ParagraphStateAtSelection::AppendDescendantFormatNodesAndFirstInlineNode( + nsTArray>& aArrayOfContents, + dom::Element& aNonFormatBlockElement) { + MOZ_ASSERT(HTMLEditUtils::IsBlockElement(aNonFormatBlockElement)); + MOZ_ASSERT(!HTMLEditUtils::IsFormatNode(&aNonFormatBlockElement)); + + // We only need to place any one inline inside this node onto + // the list. They are all the same for purposes of determining + // paragraph style. We use foundInline to track this as we are + // going through the children in the loop below. + bool foundInline = false; + for (nsIContent* childContent = aNonFormatBlockElement.GetFirstChild(); + childContent; childContent = childContent->GetNextSibling()) { + bool isBlock = HTMLEditUtils::IsBlockElement(*childContent); + bool isFormat = HTMLEditUtils::IsFormatNode(childContent); + // If the child is a non-format block element, let's check its children + // recursively. + if (isBlock && !isFormat) { + ParagraphStateAtSelection::AppendDescendantFormatNodesAndFirstInlineNode( + aArrayOfContents, *childContent->AsElement()); + continue; + } + + // If it's a format block, append it. + if (isFormat) { + aArrayOfContents.AppendElement(*childContent); + continue; + } + + MOZ_ASSERT(!isBlock); + + // If we haven't found inline node, append only this first inline node. + // XXX I think that this makes sense if caller of this removes + // aNonFormatBlockElement from aArrayOfContents because the last loop + // of the constructor can check parent format block with + // aNonFormatBlockElement. + if (!foundInline) { + foundInline = true; + aArrayOfContents.AppendElement(*childContent); + continue; + } + } +} + +// static +nsresult ParagraphStateAtSelection::CollectEditableFormatNodesInSelection( + HTMLEditor& aHTMLEditor, const Element& aEditingHost, + nsTArray>& aArrayOfContents) { + { + AutoRangeArray extendedSelectionRanges(aHTMLEditor.SelectionRef()); + extendedSelectionRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eCreateOrRemoveBlock, aEditingHost); + nsresult rv = extendedSelectionRanges.CollectEditTargetNodes( + aHTMLEditor, aArrayOfContents, EditSubAction::eCreateOrRemoveBlock, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::" + "eCreateOrRemoveBlock, CollectNonEditableNodes::Yes) failed"); + return rv; + } + } + + // Pre-process our list of nodes + for (int32_t i = aArrayOfContents.Length() - 1; i >= 0; i--) { + OwningNonNull content = aArrayOfContents[i]; + + // Remove all non-editable nodes. Leave them be. + if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { + aArrayOfContents.RemoveElementAt(i); + continue; + } + + // Scan for table elements. If we find table elements other than table, + // replace it with a list of any editable non-table content. Ditto for + // list elements. + if (HTMLEditUtils::IsAnyTableElement(content) || + HTMLEditUtils::IsAnyListElement(content) || + HTMLEditUtils::IsListItem(content)) { + aArrayOfContents.RemoveElementAt(i); + HTMLEditUtils::CollectChildren( + content, aArrayOfContents, i, + {CollectChildrenOption::CollectListChildren, + CollectChildrenOption::CollectTableChildren}); + } + } + return NS_OK; +} + +} // namespace mozilla -- cgit v1.2.3