Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-21 17:25:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1156062 part 12 - Clean up nsHTMLEditRules::GetAlignment; r=masayuki

Browse Source
This commit is contained in:
Aryeh Gregor 2016-05-01 16:11:16 +03:00
parent d47825b953
commit b54341c0b9
1 changed files with 84 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
editor/libeditor/nsHTMLEditRules.cpp
View File

@ -798,153 +798,128 @@ nsHTMLEditRules::GetListItemState(bool *aMixed, bool *aLI, bool *aDT, bool *aDD)
} }
nsresult nsresult
nsHTMLEditRules::GetAlignment(bool *aMixed, nsIHTMLEditor::EAlignment *aAlign) nsHTMLEditRules::GetAlignment(bool* aMixed, nsIHTMLEditor::EAlignment* aAlign)
{ {
// for now, just return first alignment. we'll lie about MOZ_ASSERT(aMixed && aAlign);
// if it's mixed. This is for efficiency
// given that our current ui doesn't care if it's mixed.
// cmanske: NOT TRUE! We would like to pay attention to mixed state
// in Format | Align submenu!
// this routine assumes that alignment is done ONLY via divs NS_ENSURE_STATE(mHTMLEditor);
nsCOMPtr<nsIEditor> kungFuDeathGrip(mHTMLEditor);
// default alignment is left // For now, just return first alignment. We'll lie about if it's mixed.
NS_ENSURE_TRUE(aMixed && aAlign, NS_ERROR_NULL_POINTER); // This is for efficiency given that our current ui doesn't care if it's
// mixed.
// cmanske: NOT TRUE! We would like to pay attention to mixed state in Format
// | Align submenu!
// This routine assumes that alignment is done ONLY via divs
// Default alignment is left
*aMixed = false; *aMixed = false;
*aAlign = nsIHTMLEditor::eLeft; *aAlign = nsIHTMLEditor::eLeft;
// get selection // Get selection
NS_ENSURE_STATE(mHTMLEditor); NS_ENSURE_STATE(mHTMLEditor->GetSelection());
RefPtr<Selection> selection = mHTMLEditor->GetSelection(); OwningNonNull<Selection> selection = *mHTMLEditor->GetSelection();
NS_ENSURE_STATE(selection);
// get selection location // Get selection location
NS_ENSURE_STATE(mHTMLEditor); NS_ENSURE_TRUE(mHTMLEditor->GetRoot(), NS_ERROR_FAILURE);
nsCOMPtr<Element> rootElem = mHTMLEditor->GetRoot(); OwningNonNull<Element> root = *mHTMLEditor->GetRoot();
NS_ENSURE_TRUE(rootElem, NS_ERROR_FAILURE);
int32_t offset, rootOffset; int32_t rootOffset = root->GetParentNode() ?
nsCOMPtr<nsINode> parent = nsEditor::GetNodeLocation(rootElem, &rootOffset); root->GetParentNode()->IndexOf(root) : -1;
NS_ENSURE_STATE(mHTMLEditor);
nsresult res = mHTMLEditor->GetStartNodeAndOffset(selection,
getter_AddRefs(parent),
&offset);
NS_ENSURE_SUCCESS(res, res);
// is the selection collapsed? NS_ENSURE_STATE(selection->GetRangeAt(0) &&
selection->GetRangeAt(0)->GetStartParent());
OwningNonNull<nsINode> parent = *selection->GetRangeAt(0)->GetStartParent();
int32_t offset = selection->GetRangeAt(0)->StartOffset();
// Is the selection collapsed?
nsCOMPtr<nsINode> nodeToExamine; nsCOMPtr<nsINode> nodeToExamine;
if (selection->Collapsed()) { if (selection->Collapsed() || parent->GetAsText()) {
// if it is, we want to look at 'parent' and its ancestors // If selection is collapsed, we want to look at 'parent' and its ancestors
// for divs with alignment on them // for divs with alignment on them. If we are in a text node, then that is
nodeToExamine = parent; // the node of interest.
}
else if (!mHTMLEditor) {
return NS_ERROR_UNEXPECTED;
}
else if (mHTMLEditor->IsTextNode(parent))
{
// if we are in a text node, then that is the node of interest
nodeToExamine = parent; nodeToExamine = parent;
} else if (parent->IsHTMLElement(nsGkAtoms::html) && offset == rootOffset) { } else if (parent->IsHTMLElement(nsGkAtoms::html) && offset == rootOffset) {
// if we have selected the body, let's look at the first editable node // If we have selected the body, let's look at the first editable node
NS_ENSURE_STATE(mHTMLEditor);
nodeToExamine = mHTMLEditor->GetNextNode(parent, offset, true); nodeToExamine = mHTMLEditor->GetNextNode(parent, offset, true);
} } else {
else
{
nsTArray<RefPtr<nsRange>> arrayOfRanges; nsTArray<RefPtr<nsRange>> arrayOfRanges;
GetPromotedRanges(*selection, arrayOfRanges, EditAction::align); GetPromotedRanges(selection, arrayOfRanges, EditAction::align);
// use these ranges to construct a list of nodes to act on. // Use these ranges to construct a list of nodes to act on.
nsTArray<OwningNonNull<nsINode>> arrayOfNodes; nsTArray<OwningNonNull<nsINode>> arrayOfNodes;
res = GetNodesForOperation(arrayOfRanges, arrayOfNodes, nsresult rv = GetNodesForOperation(arrayOfRanges, arrayOfNodes,
EditAction::align, TouchContent::no); EditAction::align, TouchContent::no);
NS_ENSURE_SUCCESS(res, res); NS_ENSURE_SUCCESS(rv, rv);
nodeToExamine = arrayOfNodes.SafeElementAt(0); nodeToExamine = arrayOfNodes.SafeElementAt(0);
} }
NS_ENSURE_TRUE(nodeToExamine, NS_ERROR_NULL_POINTER); NS_ENSURE_TRUE(nodeToExamine, NS_ERROR_NULL_POINTER);
NS_NAMED_LITERAL_STRING(typeAttrName, "align"); NS_NAMED_LITERAL_STRING(typeAttrName, "align");
nsIAtom *dummyProperty = nullptr;
NS_ENSURE_STATE(mHTMLEditor);
nsCOMPtr<Element> blockParent = mHTMLEditor->GetBlock(*nodeToExamine); nsCOMPtr<Element> blockParent = mHTMLEditor->GetBlock(*nodeToExamine);
NS_ENSURE_TRUE(blockParent, NS_ERROR_FAILURE); NS_ENSURE_TRUE(blockParent, NS_ERROR_FAILURE);
NS_ENSURE_STATE(mHTMLEditor); if (mHTMLEditor->IsCSSEnabled() &&
if (mHTMLEditor->IsCSSEnabled()) mHTMLEditor->mHTMLCSSUtils->IsCSSEditableProperty(blockParent, nullptr,
{ &typeAttrName)) {
NS_ENSURE_STATE(mHTMLEditor); // We are in CSS mode and we know how to align this element with CSS
if (mHTMLEditor->mHTMLCSSUtils->IsCSSEditableProperty(blockParent, nsAutoString value;
dummyProperty, // Let's get the value(s) of text-align or margin-left/margin-right
&typeAttrName)) { mHTMLEditor->mHTMLCSSUtils->GetCSSEquivalentToHTMLInlineStyleSet(
// we are in CSS mode and we know how to align this element with CSS blockParent, nullptr, &typeAttrName, value, nsHTMLCSSUtils::eComputed);
nsAutoString value; if (value.EqualsLiteral("center") ||
// let's get the value(s) of text-align or margin-left/margin-right value.EqualsLiteral("-moz-center") ||
NS_ENSURE_STATE(mHTMLEditor); value.EqualsLiteral("auto auto")) {
mHTMLEditor->mHTMLCSSUtils->GetCSSEquivalentToHTMLInlineStyleSet( *aAlign = nsIHTMLEditor::eCenter;
blockParent, dummyProperty, &typeAttrName, value,
nsHTMLCSSUtils::eComputed);
if (value.EqualsLiteral("center") ||
value.EqualsLiteral("-moz-center") ||
value.EqualsLiteral("auto auto"))
{
*aAlign = nsIHTMLEditor::eCenter;
return NS_OK;
}
if (value.EqualsLiteral("right") ||
value.EqualsLiteral("-moz-right") ||
value.EqualsLiteral("auto 0px"))
{
*aAlign = nsIHTMLEditor::eRight;
return NS_OK;
}
if (value.EqualsLiteral("justify"))
{
*aAlign = nsIHTMLEditor::eJustify;
return NS_OK;
}
*aAlign = nsIHTMLEditor::eLeft;
return NS_OK; return NS_OK;
} }
if (value.EqualsLiteral("right") ||
value.EqualsLiteral("-moz-right") ||
value.EqualsLiteral("auto 0px")) {
*aAlign = nsIHTMLEditor::eRight;
return NS_OK;
}
if (value.EqualsLiteral("justify")) {
*aAlign = nsIHTMLEditor::eJustify;
return NS_OK;
}
*aAlign = nsIHTMLEditor::eLeft;
return NS_OK;
} }
// check up the ladder for divs with alignment // Check up the ladder for divs with alignment
bool isFirstNodeToExamine = true; bool isFirstNodeToExamine = true;
while (nodeToExamine) for (; nodeToExamine; nodeToExamine = nodeToExamine->GetParentNode()) {
{ if (!isFirstNodeToExamine &&
if (!isFirstNodeToExamine && nsHTMLEditUtils::IsTable(nodeToExamine)) nodeToExamine->IsHTMLElement(nsGkAtoms::table)) {
{ // The node to examine is a table and this is not the first node we
// the node to examine is a table and this is not the first node // examine; let's break here to materialize the 'inline-block' behaviour
// we examine; let's break here to materialize the 'inline-block' // of html tables regarding to text alignment
// behaviour of html tables regarding to text alignment
return NS_OK; return NS_OK;
} }
if (nsHTMLEditUtils::SupportsAlignAttr(GetAsDOMNode(nodeToExamine))) { if (nsHTMLEditUtils::SupportsAlignAttr(GetAsDOMNode(nodeToExamine))) {
// check for alignment // Check for alignment
nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(nodeToExamine); nsAutoString typeAttrVal;
if (elem) nodeToExamine->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::align,
{ typeAttrVal);
nsAutoString typeAttrVal; ToLowerCase(typeAttrVal);
res = elem->GetAttribute(NS_LITERAL_STRING("align"), typeAttrVal); if (!typeAttrVal.IsEmpty()) {
ToLowerCase(typeAttrVal); if (typeAttrVal.EqualsLiteral("center")) {
if (NS_SUCCEEDED(res) && typeAttrVal.Length()) *aAlign = nsIHTMLEditor::eCenter;
{ } else if (typeAttrVal.EqualsLiteral("right")) {
if (typeAttrVal.EqualsLiteral("center")) *aAlign = nsIHTMLEditor::eRight;
*aAlign = nsIHTMLEditor::eCenter; } else if (typeAttrVal.EqualsLiteral("justify")) {
else if (typeAttrVal.EqualsLiteral("right")) *aAlign = nsIHTMLEditor::eJustify;
*aAlign = nsIHTMLEditor::eRight; } else {
else if (typeAttrVal.EqualsLiteral("justify")) *aAlign = nsIHTMLEditor::eLeft;
*aAlign = nsIHTMLEditor::eJustify;
else
*aAlign = nsIHTMLEditor::eLeft;
return res;
} }
return NS_OK;
} }
} }
isFirstNodeToExamine = false; isFirstNodeToExamine = false;
nodeToExamine = nodeToExamine->GetParentNode();
} }
return NS_OK; return NS_OK;
} }