The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim: set ts=2 sw=2 et tw=79: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include <stdlib.h>

 #include "mozilla/Assertions.h"

 #include "mozilla/MathAlgorithms.h"

 #include "mozilla/Preferences.h"

 #include "mozilla/dom/Selection.h"

 #include "mozilla/dom/Element.h"

 #include "mozilla/mozalloc.h"

 #include "nsAString.h"

 #include "nsAlgorithm.h"

 #include "nsCOMArray.h"

 #include "nsCRT.h"

 #include "nsCRTGlue.h"

 #include "nsComponentManagerUtils.h"

 #include "nsContentUtils.h"

 #include "nsDebug.h"

 #include "nsEditProperty.h"

 #include "nsEditor.h"

 #include "nsEditorUtils.h"

 #include "nsError.h"

 #include "nsGkAtoms.h"

 #include "nsHTMLCSSUtils.h"

 #include "nsHTMLEditRules.h"

 #include "nsHTMLEditUtils.h"

 #include "nsHTMLEditor.h"

 #include "nsIAtom.h"

 #include "nsIContent.h"

 #include "nsIContentIterator.h"

 #include "nsID.h"

 #include "nsIDOMCharacterData.h"

 #include "nsIDOMDocument.h"

 #include "nsIDOMElement.h"

 #include "nsIDOMNode.h"

 #include "nsIDOMRange.h"

 #include "nsIDOMText.h"

 #include "nsIHTMLAbsPosEditor.h"

 #include "nsIHTMLDocument.h"

 #include "nsINode.h"

 #include "nsISelection.h"

 #include "nsISelectionPrivate.h"

 #include "nsLiteralString.h"

 #include "nsPlaintextEditor.h"

 #include "nsRange.h"

 #include "nsReadableUtils.h"

 #include "nsString.h"

 #include "nsStringFwd.h"

 #include "nsTArray.h"

 #include "nsTextEditUtils.h"

 #include "nsThreadUtils.h"

 #include "nsUnicharUtils.h"

 #include "nsWSRunObject.h"

 #include <algorithm>

 class nsISupports;

 class nsRulesInfo;

 using namespace mozilla;

 using namespace mozilla::dom;

 //const static char* kMOZEditorBogusNodeAttr="MOZ_EDITOR_BOGUS_NODE";

 //const static char* kMOZEditorBogusNodeValue="TRUE";

 enum

 {

   kLonely = 0,

   kPrevSib = 1,

   kNextSib = 2,

   kBothSibs = 3

 };

 /********************************************************

  *  first some helpful functors we will use

  ********************************************************/

 static bool IsBlockNode(nsIDOMNode* node)

 {

   bool isBlock (false);

   nsHTMLEditor::NodeIsBlockStatic(node, &isBlock);

   return isBlock;

 }

 static bool IsInlineNode(nsIDOMNode* node)

 {

   return !IsBlockNode(node);

 }

 static bool

 IsStyleCachePreservingAction(EditAction action)

 {

   return action == EditAction::deleteSelection ||

          action == EditAction::insertBreak ||

          action == EditAction::makeList ||

          action == EditAction::indent ||

          action == EditAction::outdent ||

          action == EditAction::align ||

          action == EditAction::makeBasicBlock ||

          action == EditAction::removeList ||

          action == EditAction::makeDefListItem ||

          action == EditAction::insertElement ||

          action == EditAction::insertQuotation;

 }

 class nsTableCellAndListItemFunctor : public nsBoolDomIterFunctor

 {

   public:

     virtual bool operator()(nsIDOMNode* aNode)  // used to build list of all li's, td's & th's iterator covers

     {

       if (nsHTMLEditUtils::IsTableCell(aNode)) return true;

       if (nsHTMLEditUtils::IsListItem(aNode)) return true;

       return false;

     }

 };

 class nsBRNodeFunctor : public nsBoolDomIterFunctor

 {

   public:

     virtual bool operator()(nsIDOMNode* aNode)  

     {

       if (nsTextEditUtils::IsBreak(aNode)) return true;

       return false;

     }

 };

 class nsEmptyEditableFunctor : public nsBoolDomIterFunctor

 {

   public:

     nsEmptyEditableFunctor(nsHTMLEditor* editor) : mHTMLEditor(editor) {}

     virtual bool operator()(nsIDOMNode* aNode)  

     {

       if (mHTMLEditor->IsEditable(aNode) &&

         (nsHTMLEditUtils::IsListItem(aNode) ||

         nsHTMLEditUtils::IsTableCellOrCaption(aNode)))

       {

         bool bIsEmptyNode;

         nsresult res = mHTMLEditor->IsEmptyNode(aNode, &bIsEmptyNode, false, false);

         NS_ENSURE_SUCCESS(res, false);

         if (bIsEmptyNode)

           return true;

       }

       return false;

     }

   protected:

     nsHTMLEditor* mHTMLEditor;

 };

 class nsEditableTextFunctor : public nsBoolDomIterFunctor

 {

   public:

     nsEditableTextFunctor(nsHTMLEditor* editor) : mHTMLEditor(editor) {}

     virtual bool operator()(nsIDOMNode* aNode)  

     {

       if (nsEditor::IsTextNode(aNode) && mHTMLEditor->IsEditable(aNode)) 

       {

         return true;

       }

       return false;

     }

   protected:

     nsHTMLEditor* mHTMLEditor;

 };

 /********************************************************

  *  Constructor/Destructor 

  ********************************************************/

 nsHTMLEditRules::nsHTMLEditRules()

 {

   InitFields();

 }

 void

 nsHTMLEditRules::InitFields()

 {

   mHTMLEditor = nullptr;

   mDocChangeRange = nullptr;

   mListenerEnabled = true;

   mReturnInEmptyLIKillsList = true;

   mDidDeleteSelection = false;

   mDidRangedDelete = false;

   mRestoreContentEditableCount = false;

   mUtilRange = nullptr;

   mJoinOffset = 0;

   mNewBlock = nullptr;

   mRangeItem = new nsRangeStore();

   // populate mCachedStyles

   mCachedStyles[0] = StyleCache(nsEditProperty::b, EmptyString(), EmptyString());

   mCachedStyles[1] = StyleCache(nsEditProperty::i, EmptyString(), EmptyString());

   mCachedStyles[2] = StyleCache(nsEditProperty::u, EmptyString(), EmptyString());

   mCachedStyles[3] = StyleCache(nsEditProperty::font, NS_LITERAL_STRING("face"), EmptyString());

   mCachedStyles[4] = StyleCache(nsEditProperty::font, NS_LITERAL_STRING("size"), EmptyString());

   mCachedStyles[5] = StyleCache(nsEditProperty::font, NS_LITERAL_STRING("color"), EmptyString());

   mCachedStyles[6] = StyleCache(nsEditProperty::tt, EmptyString(), EmptyString());

   mCachedStyles[7] = StyleCache(nsEditProperty::em, EmptyString(), EmptyString());

   mCachedStyles[8] = StyleCache(nsEditProperty::strong, EmptyString(), EmptyString());

   mCachedStyles[9] = StyleCache(nsEditProperty::dfn, EmptyString(), EmptyString());

   mCachedStyles[10] = StyleCache(nsEditProperty::code, EmptyString(), EmptyString());

   mCachedStyles[11] = StyleCache(nsEditProperty::samp, EmptyString(), EmptyString());

   mCachedStyles[12] = StyleCache(nsEditProperty::var, EmptyString(), EmptyString());

   mCachedStyles[13] = StyleCache(nsEditProperty::cite, EmptyString(), EmptyString());

   mCachedStyles[14] = StyleCache(nsEditProperty::abbr, EmptyString(), EmptyString());

   mCachedStyles[15] = StyleCache(nsEditProperty::acronym, EmptyString(), EmptyString());

   mCachedStyles[16] = StyleCache(nsEditProperty::cssBackgroundColor, EmptyString(), EmptyString());

   mCachedStyles[17] = StyleCache(nsEditProperty::sub, EmptyString(), EmptyString());

   mCachedStyles[18] = StyleCache(nsEditProperty::sup, EmptyString(), EmptyString());

 }

 nsHTMLEditRules::~nsHTMLEditRules()

 {

   // remove ourselves as a listener to edit actions

   // In some cases, we have already been removed by 

   // ~nsHTMLEditor, in which case we will get a null pointer here

   // which we ignore.  But this allows us to add the ability to

   // switch rule sets on the fly if we want.

   if (mHTMLEditor)

     mHTMLEditor->RemoveEditActionListener(this);

 }

 /********************************************************

  *  XPCOM Cruft

  ********************************************************/

 NS_IMPL_ADDREF_INHERITED(nsHTMLEditRules, nsTextEditRules)

 NS_IMPL_RELEASE_INHERITED(nsHTMLEditRules, nsTextEditRules)

 NS_IMPL_QUERY_INTERFACE_INHERITED(nsHTMLEditRules, nsTextEditRules, nsIEditActionListener)

 /********************************************************

  *  Public methods 

  ********************************************************/

 NS_IMETHODIMP

 nsHTMLEditRules::Init(nsPlaintextEditor *aEditor)

 {

   InitFields();

   mHTMLEditor = static_cast<nsHTMLEditor*>(aEditor);

   nsresult res;

   // call through to base class Init 

   res = nsTextEditRules::Init(aEditor);

   NS_ENSURE_SUCCESS(res, res);

   // cache any prefs we care about

   static const char kPrefName[] =

     "editor.html.typing.returnInEmptyListItemClosesList";

   nsAdoptingCString returnInEmptyLIKillsList =

     Preferences::GetCString(kPrefName);

   // only when "false", becomes FALSE.  Otherwise (including empty), TRUE.

   // XXX Why was this pref designed as a string and not bool?

   mReturnInEmptyLIKillsList = !returnInEmptyLIKillsList.EqualsLiteral("false");

   // make a utility range for use by the listenter

   nsCOMPtr<nsINode> node = mHTMLEditor->GetRoot();

   if (!node) {

     node = mHTMLEditor->GetDocument();

   }

   NS_ENSURE_STATE(node);

   mUtilRange = new nsRange(node);

   // set up mDocChangeRange to be whole doc

   // temporarily turn off rules sniffing

   nsAutoLockRulesSniffing lockIt((nsTextEditRules*)this);

   if (!mDocChangeRange) {

     mDocChangeRange = new nsRange(node);

   }

   if (node->IsElement()) {

     ErrorResult rv;

     mDocChangeRange->SelectNode(*node, rv);

     res = AdjustSpecialBreaks(node);

     NS_ENSURE_SUCCESS(res, res);

   }

   // add ourselves as a listener to edit actions

   res = mHTMLEditor->AddEditActionListener(this);

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditRules::DetachEditor()

 {

   if (mHTMLEditor) {

     mHTMLEditor->RemoveEditActionListener(this);

   }

   mHTMLEditor = nullptr;

   return nsTextEditRules::DetachEditor();

 }

 NS_IMETHODIMP

 nsHTMLEditRules::BeforeEdit(EditAction action,

                             nsIEditor::EDirection aDirection)

 {

   if (mLockRulesSniffing) return NS_OK;

   nsAutoLockRulesSniffing lockIt((nsTextEditRules*)this);

   mDidExplicitlySetInterline = false;

   if (!mActionNesting++)

   {

     // clear our flag about if just deleted a range

     mDidRangedDelete = false;

     // remember where our selection was before edit action took place:

     // get selection

     nsCOMPtr<nsISelection> selection;

     NS_ENSURE_STATE(mHTMLEditor);

     nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));

     NS_ENSURE_SUCCESS(res, res);

     // get the selection start location

     nsCOMPtr<nsIDOMNode> selStartNode, selEndNode;

     int32_t selOffset;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(selStartNode), &selOffset);

     NS_ENSURE_SUCCESS(res, res);

     mRangeItem->startNode = selStartNode;

     mRangeItem->startOffset = selOffset;

     // get the selection end location

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetEndNodeAndOffset(selection, getter_AddRefs(selEndNode), &selOffset);

     NS_ENSURE_SUCCESS(res, res);

     mRangeItem->endNode = selEndNode;

     mRangeItem->endOffset = selOffset;

     // register this range with range updater to track this as we perturb the doc

     NS_ENSURE_STATE(mHTMLEditor);

     (mHTMLEditor->mRangeUpdater).RegisterRangeItem(mRangeItem);

     // clear deletion state bool

     mDidDeleteSelection = false;

     // clear out mDocChangeRange and mUtilRange

     if(mDocChangeRange)

     {

       // clear out our accounting of what changed

       mDocChangeRange->Reset(); 

     }

     if(mUtilRange)

     {

       // ditto for mUtilRange.

       mUtilRange->Reset(); 

     }

     // remember current inline styles for deletion and normal insertion operations

     if (action == EditAction::insertText ||

         action == EditAction::insertIMEText ||

         action == EditAction::deleteSelection ||

         IsStyleCachePreservingAction(action)) {

       nsCOMPtr<nsIDOMNode> selNode = selStartNode;

       if (aDirection == nsIEditor::eNext)

         selNode = selEndNode;

       res = CacheInlineStyles(selNode);

       NS_ENSURE_SUCCESS(res, res);

     }

     // Stabilize the document against contenteditable count changes

     NS_ENSURE_STATE(mHTMLEditor);

     nsCOMPtr<nsIDOMDocument> doc = mHTMLEditor->GetDOMDocument();

     NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);

     nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(doc);

     NS_ENSURE_TRUE(htmlDoc, NS_ERROR_FAILURE);

     if (htmlDoc->GetEditingState() == nsIHTMLDocument::eContentEditable) {

       htmlDoc->ChangeContentEditableCount(nullptr, +1);

       mRestoreContentEditableCount = true;

     }

     // check that selection is in subtree defined by body node

     ConfirmSelectionInBody();

     // let rules remember the top level action

     mTheAction = action;

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 nsHTMLEditRules::AfterEdit(EditAction action,

                            nsIEditor::EDirection aDirection)

 {

   if (mLockRulesSniffing) return NS_OK;

   nsAutoLockRulesSniffing lockIt(this);

   NS_PRECONDITION(mActionNesting>0, "bad action nesting!");

   nsresult res = NS_OK;

   if (!--mActionNesting)

   {

     // do all the tricky stuff

     res = AfterEditInner(action, aDirection);

     // free up selectionState range item

     NS_ENSURE_STATE(mHTMLEditor);

     (mHTMLEditor->mRangeUpdater).DropRangeItem(mRangeItem);

     // Reset the contenteditable count to its previous value

     if (mRestoreContentEditableCount) {

       NS_ENSURE_STATE(mHTMLEditor);

       nsCOMPtr<nsIDOMDocument> doc = mHTMLEditor->GetDOMDocument();

       NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);

       nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(doc);

       NS_ENSURE_TRUE(htmlDoc, NS_ERROR_FAILURE);

       if (htmlDoc->GetEditingState() == nsIHTMLDocument::eContentEditable) {

         htmlDoc->ChangeContentEditableCount(nullptr, -1);

       }

       mRestoreContentEditableCount = false;

     }

   }

   return res;

 }

 nsresult

 nsHTMLEditRules::AfterEditInner(EditAction action,

                                 nsIEditor::EDirection aDirection)

 {

   ConfirmSelectionInBody();

   if (action == EditAction::ignore) return NS_OK;

   nsCOMPtr<nsISelection>selection;

   NS_ENSURE_STATE(mHTMLEditor);

   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMNode> rangeStartParent, rangeEndParent;

   int32_t rangeStartOffset = 0, rangeEndOffset = 0;

   // do we have a real range to act on?

   bool bDamagedRange = false;  

   if (mDocChangeRange)

   {  

     mDocChangeRange->GetStartContainer(getter_AddRefs(rangeStartParent));

     mDocChangeRange->GetEndContainer(getter_AddRefs(rangeEndParent));

     mDocChangeRange->GetStartOffset(&rangeStartOffset);

     mDocChangeRange->GetEndOffset(&rangeEndOffset);

     if (rangeStartParent && rangeEndParent) 

       bDamagedRange = true; 

   }

   if (bDamagedRange && !((action == EditAction::undo) || (action == EditAction::redo)))

   {

     // don't let any txns in here move the selection around behind our back.

     // Note that this won't prevent explicit selection setting from working.

     NS_ENSURE_STATE(mHTMLEditor);

     nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);

     // expand the "changed doc range" as needed

     res = PromoteRange(mDocChangeRange, action);

     NS_ENSURE_SUCCESS(res, res);

     // if we did a ranged deletion, make sure we have a place to put caret.

     // Note we only want to do this if the overall operation was deletion,

     // not if deletion was done along the way for EditAction::loadHTML, EditAction::insertText, etc.

     // That's why this is here rather than DidDeleteSelection().

     if ((action == EditAction::deleteSelection) && mDidRangedDelete)

     {

       res = InsertBRIfNeeded(selection);

       NS_ENSURE_SUCCESS(res, res);

     }  

     // add in any needed <br>s, and remove any unneeded ones.

     res = AdjustSpecialBreaks();

     NS_ENSURE_SUCCESS(res, res);

     // merge any adjacent text nodes

     if ( (action != EditAction::insertText &&

          action != EditAction::insertIMEText) )

     {

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->CollapseAdjacentTextNodes(mDocChangeRange);

       NS_ENSURE_SUCCESS(res, res);

     }

     // clean up any empty nodes in the selection

     res = RemoveEmptyNodes();

     NS_ENSURE_SUCCESS(res, res);

     // attempt to transform any unneeded nbsp's into spaces after doing various operations

     if ((action == EditAction::insertText) || 

         (action == EditAction::insertIMEText) ||

         (action == EditAction::deleteSelection) ||

         (action == EditAction::insertBreak) || 

         (action == EditAction::htmlPaste ||

         (action == EditAction::loadHTML)))

     {

       res = AdjustWhitespace(selection);

       NS_ENSURE_SUCCESS(res, res);

       // also do this for original selection endpoints. 

       NS_ENSURE_STATE(mHTMLEditor);

       nsWSRunObject(mHTMLEditor, mRangeItem->startNode,

                     mRangeItem->startOffset).AdjustWhitespace();

       // we only need to handle old selection endpoint if it was different from start

       if (mRangeItem->startNode != mRangeItem->endNode ||

           mRangeItem->startOffset != mRangeItem->endOffset) {

         NS_ENSURE_STATE(mHTMLEditor);

         nsWSRunObject(mHTMLEditor, mRangeItem->endNode,

                       mRangeItem->endOffset).AdjustWhitespace();

       }

     }

     // if we created a new block, make sure selection lands in it

     if (mNewBlock)

     {

       res = PinSelectionToNewBlock(selection);

       mNewBlock = 0;

     }

     // adjust selection for insert text, html paste, and delete actions

     if ((action == EditAction::insertText) || 

         (action == EditAction::insertIMEText) ||

         (action == EditAction::deleteSelection) ||

         (action == EditAction::insertBreak) || 

         (action == EditAction::htmlPaste ||

         (action == EditAction::loadHTML)))

     {

       res = AdjustSelection(selection, aDirection);

       NS_ENSURE_SUCCESS(res, res);

     }

     // check for any styles which were removed inappropriately

     if (action == EditAction::insertText ||

         action == EditAction::insertIMEText ||

         action == EditAction::deleteSelection ||

         IsStyleCachePreservingAction(action)) {

       NS_ENSURE_STATE(mHTMLEditor);

       mHTMLEditor->mTypeInState->UpdateSelState(selection);

       res = ReapplyCachedStyles();

       NS_ENSURE_SUCCESS(res, res);

       ClearCachedStyles();

     }    

   }

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->HandleInlineSpellCheck(action, selection, 

                                             mRangeItem->startNode,

                                             mRangeItem->startOffset,

                                             rangeStartParent, rangeStartOffset,

                                             rangeEndParent, rangeEndOffset);

   NS_ENSURE_SUCCESS(res, res);

   // detect empty doc

   res = CreateBogusNodeIfNeeded(selection);

   // adjust selection HINT if needed

   NS_ENSURE_SUCCESS(res, res);

   if (!mDidExplicitlySetInterline)

   {

     res = CheckInterlinePosition(selection);

   }

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditRules::WillDoAction(Selection* aSelection,

                               nsRulesInfo* aInfo,

                               bool* aCancel,

                               bool* aHandled)

 {

   MOZ_ASSERT(aInfo && aCancel && aHandled);

   *aCancel = false;

   *aHandled = false;

   // my kingdom for dynamic cast

   nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);

   // Deal with actions for which we don't need to check whether the selection is

   // editable.

   if (info->action == EditAction::outputText ||

       info->action == EditAction::undo ||

       info->action == EditAction::redo) {

     return nsTextEditRules::WillDoAction(aSelection, aInfo, aCancel, aHandled);

   }

   // Nothing to do if there's no selection to act on

   if (!aSelection) {

     return NS_OK;

   }

   NS_ENSURE_TRUE(aSelection->GetRangeCount(), NS_OK);

   nsRefPtr<nsRange> range = aSelection->GetRangeAt(0);

   nsCOMPtr<nsINode> selStartNode = range->GetStartParent();

   NS_ENSURE_STATE(mHTMLEditor);

   if (!mHTMLEditor->IsModifiableNode(selStartNode)) {

     *aCancel = true;

     return NS_OK;

   }

   nsCOMPtr<nsINode> selEndNode = range->GetEndParent();

   if (selStartNode != selEndNode) {

     NS_ENSURE_STATE(mHTMLEditor);

     if (!mHTMLEditor->IsModifiableNode(selEndNode)) {

       *aCancel = true;

       return NS_OK;

     }

     NS_ENSURE_STATE(mHTMLEditor);

     if (!mHTMLEditor->IsModifiableNode(range->GetCommonAncestor())) {

       *aCancel = true;

       return NS_OK;

     }

   }

   switch (info->action) {

     case EditAction::insertText:

     case EditAction::insertIMEText:

       return WillInsertText(info->action, aSelection, aCancel, aHandled,

                             info->inString, info->outString, info->maxLength);

     case EditAction::loadHTML:

       return WillLoadHTML(aSelection, aCancel);

     case EditAction::insertBreak:

       return WillInsertBreak(aSelection, aCancel, aHandled);

     case EditAction::deleteSelection:

       return WillDeleteSelection(aSelection, info->collapsedAction,

                                  info->stripWrappers, aCancel, aHandled);

     case EditAction::makeList:

       return WillMakeList(aSelection, info->blockType, info->entireList,

                           info->bulletType, aCancel, aHandled);

     case EditAction::indent:

       return WillIndent(aSelection, aCancel, aHandled);

     case EditAction::outdent:

       return WillOutdent(aSelection, aCancel, aHandled);

     case EditAction::setAbsolutePosition:

       return WillAbsolutePosition(aSelection, aCancel, aHandled);

     case EditAction::removeAbsolutePosition:

       return WillRemoveAbsolutePosition(aSelection, aCancel, aHandled);

     case EditAction::align:

       return WillAlign(aSelection, info->alignType, aCancel, aHandled);

     case EditAction::makeBasicBlock:

       return WillMakeBasicBlock(aSelection, info->blockType, aCancel, aHandled);

     case EditAction::removeList:

       return WillRemoveList(aSelection, info->bOrdered, aCancel, aHandled);

     case EditAction::makeDefListItem:

       return WillMakeDefListItem(aSelection, info->blockType, info->entireList,

                                  aCancel, aHandled);

     case EditAction::insertElement:

       return WillInsert(aSelection, aCancel);

     case EditAction::decreaseZIndex:

       return WillRelativeChangeZIndex(aSelection, -1, aCancel, aHandled);

     case EditAction::increaseZIndex:

       return WillRelativeChangeZIndex(aSelection, 1, aCancel, aHandled);

     default:

       return nsTextEditRules::WillDoAction(aSelection, aInfo,

                                            aCancel, aHandled);

   }

 }

 NS_IMETHODIMP 

 nsHTMLEditRules::DidDoAction(nsISelection *aSelection,

                              nsRulesInfo *aInfo, nsresult aResult)

 {

   nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);

   switch (info->action)

   {

     case EditAction::insertBreak:

       return DidInsertBreak(aSelection, aResult);

     case EditAction::deleteSelection:

       return DidDeleteSelection(aSelection, info->collapsedAction, aResult);

     case EditAction::makeBasicBlock:

     case EditAction::indent:

     case EditAction::outdent:

     case EditAction::align:

       return DidMakeBasicBlock(aSelection, aInfo, aResult);

     case EditAction::setAbsolutePosition: {

       nsresult rv = DidMakeBasicBlock(aSelection, aInfo, aResult);

       NS_ENSURE_SUCCESS(rv, rv);

       return DidAbsolutePosition();

     }

     default:

       // pass thru to nsTextEditRules

       return nsTextEditRules::DidDoAction(aSelection, aInfo, aResult);

   }

 }

 nsresult

 nsHTMLEditRules::GetListState(bool *aMixed, bool *aOL, bool *aUL, bool *aDL)

 {

   NS_ENSURE_TRUE(aMixed && aOL && aUL && aDL, NS_ERROR_NULL_POINTER);

   *aMixed = false;

   *aOL = false;

   *aUL = false;

   *aDL = false;

   bool bNonList = false;

   nsCOMArray<nsIDOMNode> arrayOfNodes;

   nsresult res = GetListActionNodes(arrayOfNodes, false, true);

   NS_ENSURE_SUCCESS(res, res);

   // Examine list type for nodes in selection.

   int32_t listCount = arrayOfNodes.Count();

   for (int32_t i = listCount - 1; i >= 0; --i) {

     nsIDOMNode* curDOMNode = arrayOfNodes[i];

     nsCOMPtr<dom::Element> curElement = do_QueryInterface(curDOMNode);

     if (!curElement) {

       bNonList = true;

     } else if (curElement->IsHTML(nsGkAtoms::ul)) {

       *aUL = true;

     } else if (curElement->IsHTML(nsGkAtoms::ol)) {

       *aOL = true;

     } else if (curElement->IsHTML(nsGkAtoms::li)) {

       if (dom::Element* parent = curElement->GetParentElement()) {

         if (parent->IsHTML(nsGkAtoms::ul)) {

           *aUL = true;

         } else if (parent->IsHTML(nsGkAtoms::ol)) {

           *aOL = true;

         }

       }

     } else if (curElement->IsHTML(nsGkAtoms::dl) ||

                curElement->IsHTML(nsGkAtoms::dt) ||

                curElement->IsHTML(nsGkAtoms::dd)) {

       *aDL = true;

     } else {

       bNonList = true;

     }

   }  

   // hokey arithmetic with booleans

   if ((*aUL + *aOL + *aDL + bNonList) > 1) {

     *aMixed = true;

   }

   return NS_OK;

 }

 nsresult 

 nsHTMLEditRules::GetListItemState(bool *aMixed, bool *aLI, bool *aDT, bool *aDD)

 {

   NS_ENSURE_TRUE(aMixed && aLI && aDT && aDD, NS_ERROR_NULL_POINTER);

   *aMixed = false;

   *aLI = false;

   *aDT = false;

   *aDD = false;

   bool bNonList = false;

   nsCOMArray<nsIDOMNode> arrayOfNodes;

   nsresult res = GetListActionNodes(arrayOfNodes, false, true);

   NS_ENSURE_SUCCESS(res, res);

   // examine list type for nodes in selection

   int32_t listCount = arrayOfNodes.Count();

   for (int32_t i = listCount - 1; i >= 0; --i) {

     nsIDOMNode* curNode = arrayOfNodes[i];

     nsCOMPtr<dom::Element> element = do_QueryInterface(curNode);

     if (!element) {

       bNonList = true;

     } else if (element->IsHTML(nsGkAtoms::ul) ||

                element->IsHTML(nsGkAtoms::ol) ||

                element->IsHTML(nsGkAtoms::li)) {

       *aLI = true;

     } else if (element->IsHTML(nsGkAtoms::dt)) {

       *aDT = true;

     } else if (element->IsHTML(nsGkAtoms::dd)) {

       *aDD = true;

     } else if (element->IsHTML(nsGkAtoms::dl)) {

       // need to look inside dl and see which types of items it has

       bool bDT, bDD;

       GetDefinitionListItemTypes(element, &bDT, &bDD);

       *aDT |= bDT;

       *aDD |= bDD;

     } else {

       bNonList = true;

     }

   }  

   // hokey arithmetic with booleans

   if ( (*aDT + *aDD + bNonList) > 1) *aMixed = true;

   return NS_OK;

 }

 nsresult 

 nsHTMLEditRules::GetAlignment(bool *aMixed, nsIHTMLEditor::EAlignment *aAlign)

 {

   // for now, just return first alignment.  we'll lie about

   // 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

   // default alignment is left

   NS_ENSURE_TRUE(aMixed && aAlign, NS_ERROR_NULL_POINTER);

   *aMixed = false;

   *aAlign = nsIHTMLEditor::eLeft;

   // get selection

   nsCOMPtr<nsISelection>selection;

   NS_ENSURE_STATE(mHTMLEditor);  

   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   // get selection location

   NS_ENSURE_STATE(mHTMLEditor);  

   nsCOMPtr<nsIDOMElement> rootElem = do_QueryInterface(mHTMLEditor->GetRoot());

   NS_ENSURE_TRUE(rootElem, NS_ERROR_FAILURE);

   int32_t offset, rootOffset;

   nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(rootElem, &rootOffset);

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(parent), &offset);

   NS_ENSURE_SUCCESS(res, res);

   // is the selection collapsed?

   nsCOMPtr<nsIDOMNode> nodeToExamine;

   if (selection->Collapsed()) {

     // if it is, we want to look at 'parent' and its ancestors

     // for divs with alignment on them

     nodeToExamine = parent;

   }

   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;

   }

   else if (nsEditor::NodeIsType(parent, nsEditProperty::html) &&

            offset == rootOffset)

   {

     // if we have selected the body, let's look at the first editable node

     NS_ENSURE_STATE(mHTMLEditor);

     mHTMLEditor->GetNextNode(parent, offset, true, address_of(nodeToExamine));

   }

   else

   {

     nsCOMArray<nsIDOMRange> arrayOfRanges;

     res = GetPromotedRanges(selection, arrayOfRanges, EditAction::align);

     NS_ENSURE_SUCCESS(res, res);

     // use these ranges to construct a list of nodes to act on.

     nsCOMArray<nsIDOMNode> arrayOfNodes;

     res = GetNodesForOperation(arrayOfRanges, arrayOfNodes,

                                EditAction::align, true);

     NS_ENSURE_SUCCESS(res, res);                                 

     nodeToExamine = arrayOfNodes.SafeObjectAt(0);

   }

   NS_ENSURE_TRUE(nodeToExamine, NS_ERROR_NULL_POINTER);

   NS_NAMED_LITERAL_STRING(typeAttrName, "align");

   nsIAtom  *dummyProperty = nullptr;

   nsCOMPtr<nsIDOMNode> blockParent;

   NS_ENSURE_STATE(mHTMLEditor);

   if (mHTMLEditor->IsBlockNode(nodeToExamine))

     blockParent = nodeToExamine;

   else {

     NS_ENSURE_STATE(mHTMLEditor);

     blockParent = mHTMLEditor->GetBlockNodeParent(nodeToExamine);

   }

   NS_ENSURE_TRUE(blockParent, NS_ERROR_FAILURE);

   NS_ENSURE_STATE(mHTMLEditor);

   if (mHTMLEditor->IsCSSEnabled())

   {

     nsCOMPtr<nsIContent> blockParentContent = do_QueryInterface(blockParent);

     NS_ENSURE_STATE(mHTMLEditor);

     if (blockParentContent && 

         mHTMLEditor->mHTMLCSSUtils->IsCSSEditableProperty(blockParentContent, dummyProperty, &typeAttrName))

     {

       // 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

       NS_ENSURE_STATE(mHTMLEditor);

       mHTMLEditor->mHTMLCSSUtils->GetCSSEquivalentToHTMLInlineStyleSet(

         blockParentContent, 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;

     }

   }

   // check up the ladder for divs with alignment

   nsCOMPtr<nsIDOMNode> temp = nodeToExamine;

   bool isFirstNodeToExamine = true;

   while (nodeToExamine)

   {

     if (!isFirstNodeToExamine && nsHTMLEditUtils::IsTable(nodeToExamine))

     {

       // the node to examine is a table and this is not the first node

       // we examine; let's break here to materialize the 'inline-block'

       // behaviour of html tables regarding to text alignment

       return NS_OK;

     }

     if (nsHTMLEditUtils::SupportsAlignAttr(nodeToExamine))

     {

       // check for alignment

       nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(nodeToExamine);

       if (elem)

       {

         nsAutoString typeAttrVal;

         res = elem->GetAttribute(NS_LITERAL_STRING("align"), typeAttrVal);

         ToLowerCase(typeAttrVal);

         if (NS_SUCCEEDED(res) && typeAttrVal.Length())

         {

           if (typeAttrVal.EqualsLiteral("center"))

             *aAlign = nsIHTMLEditor::eCenter;

           else if (typeAttrVal.EqualsLiteral("right"))

             *aAlign = nsIHTMLEditor::eRight;

           else if (typeAttrVal.EqualsLiteral("justify"))

             *aAlign = nsIHTMLEditor::eJustify;

           else

             *aAlign = nsIHTMLEditor::eLeft;

           return res;

         }

       }

     }

     isFirstNodeToExamine = false;

     res = nodeToExamine->GetParentNode(getter_AddRefs(temp));

     if (NS_FAILED(res)) temp = nullptr;

     nodeToExamine = temp; 

   }

   return NS_OK;

 }

 nsIAtom* MarginPropertyAtomForIndent(nsHTMLCSSUtils* aHTMLCSSUtils, nsIDOMNode* aNode) {

   nsAutoString direction;

   aHTMLCSSUtils->GetComputedProperty(aNode, nsEditProperty::cssDirection, direction);

   return direction.EqualsLiteral("rtl") ?

     nsEditProperty::cssMarginRight : nsEditProperty::cssMarginLeft;

 }

 nsresult 

 nsHTMLEditRules::GetIndentState(bool *aCanIndent, bool *aCanOutdent)

 {

   NS_ENSURE_TRUE(aCanIndent && aCanOutdent, NS_ERROR_FAILURE);

   *aCanIndent = true;    

   *aCanOutdent = false;

   // get selection

   nsCOMPtr<nsISelection>selection;

   NS_ENSURE_STATE(mHTMLEditor);

   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));

   NS_ENSURE_TRUE(selPriv, NS_ERROR_FAILURE);

   // contruct a list of nodes to act on.

   nsCOMArray<nsIDOMNode> arrayOfNodes;

   res = GetNodesFromSelection(selection, EditAction::indent,

                               arrayOfNodes, true);

   NS_ENSURE_SUCCESS(res, res);

   // examine nodes in selection for blockquotes or list elements;

   // these we can outdent.  Note that we return true for canOutdent

   // if *any* of the selection is outdentable, rather than all of it.

   int32_t listCount = arrayOfNodes.Count();

   int32_t i;

   NS_ENSURE_STATE(mHTMLEditor);

   bool useCSS = mHTMLEditor->IsCSSEnabled();

   for (i=listCount-1; i>=0; i--)

   {

     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];

     if (nsHTMLEditUtils::IsNodeThatCanOutdent(curNode))

     {

       *aCanOutdent = true;

       break;

     }

     else if (useCSS) {

       // we are in CSS mode, indentation is done using the margin-left (or margin-right) property

       NS_ENSURE_STATE(mHTMLEditor);

       nsIAtom* marginProperty = MarginPropertyAtomForIndent(mHTMLEditor->mHTMLCSSUtils, curNode);

       nsAutoString value;

       // retrieve its specified value

       NS_ENSURE_STATE(mHTMLEditor);

       mHTMLEditor->mHTMLCSSUtils->GetSpecifiedProperty(curNode, marginProperty, value);

       float f;

       nsCOMPtr<nsIAtom> unit;

       // get its number part and its unit

       NS_ENSURE_STATE(mHTMLEditor);

       mHTMLEditor->mHTMLCSSUtils->ParseLength(value, &f, getter_AddRefs(unit));

       // if the number part is strictly positive, outdent is possible

       if (0 < f) {

         *aCanOutdent = true;

         break;

       }

     }

   }  

   if (!*aCanOutdent)

   {

     // if we haven't found something to outdent yet, also check the parents

     // of selection endpoints.  We might have a blockquote or list item 

     // in the parent hierarchy.

     // gather up info we need for test

     NS_ENSURE_STATE(mHTMLEditor);

     nsCOMPtr<nsIDOMNode> parent, tmp, root = do_QueryInterface(mHTMLEditor->GetRoot());

     NS_ENSURE_TRUE(root, NS_ERROR_NULL_POINTER);

     nsCOMPtr<nsISelection> selection;

     int32_t selOffset;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetSelection(getter_AddRefs(selection));

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

     // test start parent hierarchy

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(parent), &selOffset);

     NS_ENSURE_SUCCESS(res, res);

     while (parent && (parent!=root))

     {

       if (nsHTMLEditUtils::IsNodeThatCanOutdent(parent))

       {

         *aCanOutdent = true;

         break;

       }

       tmp=parent;

       tmp->GetParentNode(getter_AddRefs(parent));

     }

     // test end parent hierarchy

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetEndNodeAndOffset(selection, getter_AddRefs(parent), &selOffset);

     NS_ENSURE_SUCCESS(res, res);

     while (parent && (parent!=root))

     {

       if (nsHTMLEditUtils::IsNodeThatCanOutdent(parent))

       {

         *aCanOutdent = true;

         break;

       }

       tmp=parent;

       tmp->GetParentNode(getter_AddRefs(parent));

     }

   }

   return res;

 }

 nsresult 

 nsHTMLEditRules::GetParagraphState(bool *aMixed, nsAString &outFormat)

 {

   // This routine is *heavily* tied to our ui choices in the paragraph

   // style popup.  I can't see a way around that.

   NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);

   *aMixed = true;

   outFormat.Truncate(0);

   bool bMixed = false;

   // using "x" as an uninitialized value, since "" is meaningful

   nsAutoString formatStr(NS_LITERAL_STRING("x")); 

   nsCOMArray<nsIDOMNode> arrayOfNodes;

   nsresult res = GetParagraphFormatNodes(arrayOfNodes, true);

   NS_ENSURE_SUCCESS(res, res);

   // post process list.  We need to replace any block nodes that are not format

   // nodes with their content.  This is so we only have to look "up" the hierarchy

   // to find format nodes, instead of both up and down.

   int32_t listCount = arrayOfNodes.Count();

   int32_t i;

   for (i=listCount-1; i>=0; i--)

   {

     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];

     nsAutoString format;

     // if it is a known format node we have it easy

     if (IsBlockNode(curNode) && !nsHTMLEditUtils::IsFormatNode(curNode))

     {

       // arrayOfNodes.RemoveObject(curNode);

       res = AppendInnerFormatNodes(arrayOfNodes, curNode);

       NS_ENSURE_SUCCESS(res, res);

     }

   }

   // we might have an empty node list.  if so, find selection parent

   // and put that on the list

   listCount = arrayOfNodes.Count();

   if (!listCount)

   {

     nsCOMPtr<nsIDOMNode> selNode;

     int32_t selOffset;

     nsCOMPtr<nsISelection>selection;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetSelection(getter_AddRefs(selection));

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(selNode), &selOffset);

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_TRUE(selNode, NS_ERROR_NULL_POINTER);

     arrayOfNodes.AppendObject(selNode);

     listCount = 1;

   }

   // remember root node

   NS_ENSURE_STATE(mHTMLEditor);

   nsCOMPtr<nsIDOMElement> rootElem = do_QueryInterface(mHTMLEditor->GetRoot());

   NS_ENSURE_TRUE(rootElem, NS_ERROR_NULL_POINTER);

   // loop through the nodes in selection and examine their paragraph format

   for (i=listCount-1; i>=0; i--)

   {

     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];

     nsAutoString format;

     // if it is a known format node we have it easy

     if (nsHTMLEditUtils::IsFormatNode(curNode))

       GetFormatString(curNode, format);

     else if (IsBlockNode(curNode))

     {

       // this is a div or some other non-format block.

       // we should ignore it.  Its children were appended to this list

       // by AppendInnerFormatNodes() call above.  We will get needed

       // info when we examine them instead.

       continue;

     }

     else

     {

       nsCOMPtr<nsIDOMNode> node, tmp = curNode;

       tmp->GetParentNode(getter_AddRefs(node));

       while (node)

       {

         if (node == rootElem)

         {

           format.Truncate(0);

           break;

         }

         else if (nsHTMLEditUtils::IsFormatNode(node))

         {

           GetFormatString(node, format);

           break;

         }

         // else keep looking up

         tmp = node;

         tmp->GetParentNode(getter_AddRefs(node));

       }

     }

     // if this is the first node, we've found, remember it as the format

     if (formatStr.EqualsLiteral("x"))

       formatStr = format;

     // else make sure it matches previously found format

     else if (format != formatStr) 

     {

       bMixed = true;

       break; 

     }

   }  

   *aMixed = bMixed;

   outFormat = formatStr;

   return res;

 }

 nsresult

 nsHTMLEditRules::AppendInnerFormatNodes(nsCOMArray<nsIDOMNode>& aArray,

                                         nsIDOMNode *aNode)

 {

   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);

   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);

   return AppendInnerFormatNodes(aArray, node);

 }

 nsresult

 nsHTMLEditRules::AppendInnerFormatNodes(nsCOMArray<nsIDOMNode>& aArray,

                                         nsINode* aNode)

 {

   MOZ_ASSERT(aNode);

   // 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* child = aNode->GetFirstChild();

        child;

        child = child->GetNextSibling()) {

     bool isBlock = IsBlockNode(child->AsDOMNode());

     bool isFormat = nsHTMLEditUtils::IsFormatNode(child);

     if (isBlock && !isFormat) {

       // if it's a div, etc, recurse

       AppendInnerFormatNodes(aArray, child);

     } else if (isFormat) {

       aArray.AppendObject(child->AsDOMNode());

     } else if (!foundInline) {

       // if this is the first inline we've found, use it

       foundInline = true;      

       aArray.AppendObject(child->AsDOMNode());

     }

   }

   return NS_OK;

 }

 nsresult 

 nsHTMLEditRules::GetFormatString(nsIDOMNode *aNode, nsAString &outFormat)

 {

   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);

   if (nsHTMLEditUtils::IsFormatNode(aNode))

   {

     nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(aNode);

     atom->ToString(outFormat);

   }

   else

     outFormat.Truncate();

   return NS_OK;

 }    

 /********************************************************

  *  Protected rules methods 

  ********************************************************/

 nsresult

 nsHTMLEditRules::WillInsert(nsISelection *aSelection, bool *aCancel)

 {

   nsresult res = nsTextEditRules::WillInsert(aSelection, aCancel);

   NS_ENSURE_SUCCESS(res, res); 

   // Adjust selection to prevent insertion after a moz-BR.

   // this next only works for collapsed selections right now,

   // because selection is a pain to work with when not collapsed.

   // (no good way to extend start or end of selection), so we ignore

   // those types of selections.

   if (!aSelection->Collapsed()) {

     return NS_OK;

   }

   // if we are after a mozBR in the same block, then move selection

   // to be before it

   nsCOMPtr<nsIDOMNode> selNode, priorNode;

   int32_t selOffset;

   // get the (collapsed) selection location

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode),

                                            &selOffset);

   NS_ENSURE_SUCCESS(res, res);

   // get prior node

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetPriorHTMLNode(selNode, selOffset,

                                       address_of(priorNode));

   if (NS_SUCCEEDED(res) && priorNode && nsTextEditUtils::IsMozBR(priorNode))

   {

     nsCOMPtr<nsIDOMNode> block1, block2;

     if (IsBlockNode(selNode)) {

       block1 = selNode;

     }

     else {

       NS_ENSURE_STATE(mHTMLEditor);

       block1 = mHTMLEditor->GetBlockNodeParent(selNode);

     }

     NS_ENSURE_STATE(mHTMLEditor);

     block2 = mHTMLEditor->GetBlockNodeParent(priorNode);

     if (block1 == block2)

     {

       // if we are here then the selection is right after a mozBR

       // that is in the same block as the selection.  We need to move

       // the selection start to be before the mozBR.

       selNode = nsEditor::GetNodeLocation(priorNode, &selOffset);

       res = aSelection->Collapse(selNode,selOffset);

       NS_ENSURE_SUCCESS(res, res);

     }

   }

   if (mDidDeleteSelection &&

       (mTheAction == EditAction::insertText ||

        mTheAction == EditAction::insertIMEText ||

        mTheAction == EditAction::deleteSelection)) {

     res = ReapplyCachedStyles();

     NS_ENSURE_SUCCESS(res, res);

   }

   // For most actions we want to clear the cached styles, but there are

   // exceptions

   if (!IsStyleCachePreservingAction(mTheAction)) {

     ClearCachedStyles();

   }

   return NS_OK;

 }    

 nsresult

 nsHTMLEditRules::WillInsertText(EditAction aAction,

                                 Selection*       aSelection,

                                 bool            *aCancel,

                                 bool            *aHandled,

                                 const nsAString *inString,

                                 nsAString       *outString,

                                 int32_t          aMaxLength)

 {  

   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }

   if (inString->IsEmpty() && aAction != EditAction::insertIMEText) {

     // HACK: this is a fix for bug 19395

     // I can't outlaw all empty insertions

     // because IME transaction depend on them

     // There is more work to do to make the 

     // world safe for IME.

     *aCancel = true;

     *aHandled = false;

     return NS_OK;

   }

   // initialize out param

   *aCancel = false;

   *aHandled = true;

   nsresult res;

   nsCOMPtr<nsIDOMNode> selNode;

   int32_t selOffset;

   // If the selection isn't collapsed, delete it.  Don't delete existing inline

   // tags, because we're hopefully going to insert text (bug 787432).

   if (!aSelection->Collapsed()) {

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eNoStrip);

     NS_ENSURE_SUCCESS(res, res);

   }

   res = WillInsert(aSelection, aCancel);

   NS_ENSURE_SUCCESS(res, res);

   // initialize out param

   // we want to ignore result of WillInsert()

   *aCancel = false;

   // we need to get the doc

   NS_ENSURE_STATE(mHTMLEditor);

   nsCOMPtr<nsIDOMDocument> doc = mHTMLEditor->GetDOMDocument();

   NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);

   // for every property that is set, insert a new inline style node

   res = CreateStyleForInsertText(aSelection, doc);

   NS_ENSURE_SUCCESS(res, res);

   // get the (collapsed) selection location

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);

   NS_ENSURE_SUCCESS(res, res);

   // dont put text in places that can't have it

   NS_ENSURE_STATE(mHTMLEditor);

   if (!mHTMLEditor->IsTextNode(selNode) &&

       (!mHTMLEditor ||

        !mHTMLEditor->CanContainTag(selNode, nsGkAtoms::textTagName))) {

     return NS_ERROR_FAILURE;

   }

   if (aAction == EditAction::insertIMEText) {

     // Right now the nsWSRunObject code bails on empty strings, but IME needs 

     // the InsertTextImpl() call to still happen since empty strings are meaningful there.

     if (inString->IsEmpty())

     {

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->InsertTextImpl(*inString, address_of(selNode), &selOffset, doc);

     }

     else

     {

       NS_ENSURE_STATE(mHTMLEditor);

       nsWSRunObject wsObj(mHTMLEditor, selNode, selOffset);

       res = wsObj.InsertText(*inString, address_of(selNode), &selOffset, doc);

     }

     NS_ENSURE_SUCCESS(res, res);

   }

   else // aAction == kInsertText

   {

     // find where we are

     nsCOMPtr<nsIDOMNode> curNode = selNode;

     int32_t curOffset = selOffset;

     // is our text going to be PREformatted?  

     // We remember this so that we know how to handle tabs.

     bool isPRE;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->IsPreformatted(selNode, &isPRE);

     NS_ENSURE_SUCCESS(res, res);    

     // turn off the edit listener: we know how to

     // build the "doc changed range" ourselves, and it's

     // must faster to do it once here than to track all

     // the changes one at a time.

     nsAutoLockListener lockit(&mListenerEnabled); 

     // don't spaz my selection in subtransactions

     NS_ENSURE_STATE(mHTMLEditor);

     nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);

     nsAutoString tString(*inString);

     const char16_t *unicodeBuf = tString.get();

     nsCOMPtr<nsIDOMNode> unused;

     int32_t pos = 0;

     NS_NAMED_LITERAL_STRING(newlineStr, LFSTR);

     // for efficiency, break out the pre case separately.  This is because

     // its a lot cheaper to search the input string for only newlines than

     // it is to search for both tabs and newlines.

     if (isPRE || IsPlaintextEditor())

     {

       while (unicodeBuf && (pos != -1) && (pos < (int32_t)(*inString).Length()))

       {

         int32_t oldPos = pos;

         int32_t subStrLen;

         pos = tString.FindChar(nsCRT::LF, oldPos);

         if (pos != -1) 

         {

           subStrLen = pos - oldPos;

           // if first char is newline, then use just it

           if (subStrLen == 0)

             subStrLen = 1;

         }

         else

         {

           subStrLen = tString.Length() - oldPos;

           pos = tString.Length();

         }

         nsDependentSubstring subStr(tString, oldPos, subStrLen);

         // is it a return?

         if (subStr.Equals(newlineStr))

         {

           NS_ENSURE_STATE(mHTMLEditor);

           res = mHTMLEditor->CreateBRImpl(address_of(curNode), &curOffset, address_of(unused), nsIEditor::eNone);

           pos++;

         }

         else

         {

           NS_ENSURE_STATE(mHTMLEditor);

           res = mHTMLEditor->InsertTextImpl(subStr, address_of(curNode), &curOffset, doc);

         }

         NS_ENSURE_SUCCESS(res, res);

       }

     }

     else

     {

       NS_NAMED_LITERAL_STRING(tabStr, "\t");

       NS_NAMED_LITERAL_STRING(spacesStr, "    ");

       char specialChars[] = {TAB, nsCRT::LF, 0};

       while (unicodeBuf && (pos != -1) && (pos < (int32_t)inString->Length()))

       {

         int32_t oldPos = pos;

         int32_t subStrLen;

         pos = tString.FindCharInSet(specialChars, oldPos);

         if (pos != -1) 

         {

           subStrLen = pos - oldPos;

           // if first char is newline, then use just it

           if (subStrLen == 0)

             subStrLen = 1;

         }

         else

         {

           subStrLen = tString.Length() - oldPos;

           pos = tString.Length();

         }

         nsDependentSubstring subStr(tString, oldPos, subStrLen);

         NS_ENSURE_STATE(mHTMLEditor);

         nsWSRunObject wsObj(mHTMLEditor, curNode, curOffset);

         // is it a tab?

         if (subStr.Equals(tabStr))

         {

           res = wsObj.InsertText(spacesStr, address_of(curNode), &curOffset, doc);

           NS_ENSURE_SUCCESS(res, res);

           pos++;

         }

         // is it a return?

         else if (subStr.Equals(newlineStr))

         {

           res = wsObj.InsertBreak(address_of(curNode), &curOffset, address_of(unused), nsIEditor::eNone);

           NS_ENSURE_SUCCESS(res, res);

           pos++;

         }

         else

         {

           res = wsObj.InsertText(subStr, address_of(curNode), &curOffset, doc);

           NS_ENSURE_SUCCESS(res, res);

         }

         NS_ENSURE_SUCCESS(res, res);

       }

     }

     nsCOMPtr<nsISelection> selection(aSelection);

     nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));

     selPriv->SetInterlinePosition(false);

     if (curNode) aSelection->Collapse(curNode, curOffset);

     // manually update the doc changed range so that AfterEdit will clean up

     // the correct portion of the document.

     if (!mDocChangeRange)

     {

       nsCOMPtr<nsINode> node = do_QueryInterface(selNode);

       NS_ENSURE_STATE(node);

       mDocChangeRange = new nsRange(node);

     }

     res = mDocChangeRange->SetStart(selNode, selOffset);

     NS_ENSURE_SUCCESS(res, res);

     if (curNode)

       res = mDocChangeRange->SetEnd(curNode, curOffset);

     else

       res = mDocChangeRange->SetEnd(selNode, selOffset);

     NS_ENSURE_SUCCESS(res, res);

   }

   return res;

 }

 nsresult

 nsHTMLEditRules::WillLoadHTML(nsISelection *aSelection, bool *aCancel)

 {

   NS_ENSURE_TRUE(aSelection && aCancel, NS_ERROR_NULL_POINTER);

   *aCancel = false;

   // Delete mBogusNode if it exists. If we really need one,

   // it will be added during post-processing in AfterEditInner().

   if (mBogusNode)

   {

     mEditor->DeleteNode(mBogusNode);

     mBogusNode = nullptr;

   }

   return NS_OK;

 }

 nsresult

 nsHTMLEditRules::WillInsertBreak(Selection* aSelection,

                                  bool* aCancel, bool* aHandled)

 {

   if (!aSelection || !aCancel || !aHandled) {

     return NS_ERROR_NULL_POINTER;

   }

   // initialize out params

   *aCancel = false;

   *aHandled = false;

   // if the selection isn't collapsed, delete it.

   nsresult res = NS_OK;

   if (!aSelection->Collapsed()) {

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);

     NS_ENSURE_SUCCESS(res, res);

   }

   res = WillInsert(aSelection, aCancel);

   NS_ENSURE_SUCCESS(res, res);

   // initialize out param

   // we want to ignore result of WillInsert()

   *aCancel = false;

   // split any mailcites in the way.

   // should we abort this if we encounter table cell boundaries?

   if (IsMailEditor()) {

     res = SplitMailCites(aSelection, IsPlaintextEditor(), aHandled);

     NS_ENSURE_SUCCESS(res, res);

     if (*aHandled) {

       return NS_OK;

     }

   }

   // smart splitting rules

   nsCOMPtr<nsIDOMNode> node;

   int32_t offset;

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(node),

                                            &offset);

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);

   // do nothing if the node is read-only

   NS_ENSURE_STATE(mHTMLEditor);

   if (!mHTMLEditor->IsModifiableNode(node)) {

     *aCancel = true;

     return NS_OK;

   }

   // identify the block

   nsCOMPtr<nsIDOMNode> blockParent;

   if (IsBlockNode(node)) {

     blockParent = node;

   } else {

     NS_ENSURE_STATE(mHTMLEditor);

     blockParent = mHTMLEditor->GetBlockNodeParent(node);

   }

   NS_ENSURE_TRUE(blockParent, NS_ERROR_FAILURE);

   // if the active editing host is an inline element, or if the active editing

   // host is the block parent itself, just append a br.

   NS_ENSURE_STATE(mHTMLEditor);

   nsCOMPtr<nsIContent> hostContent = mHTMLEditor->GetActiveEditingHost();

   nsCOMPtr<nsIDOMNode> hostNode = do_QueryInterface(hostContent);

   if (!nsEditorUtils::IsDescendantOf(blockParent, hostNode)) {

     res = StandardBreakImpl(node, offset, aSelection);

     NS_ENSURE_SUCCESS(res, res);

     *aHandled = true;

     return NS_OK;

   }

   // 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.)

   bool isEmpty;

   IsEmptyBlock(blockParent, &isEmpty);

   if (isEmpty) {

     uint32_t blockLen;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetLengthOfDOMNode(blockParent, blockLen);

     NS_ENSURE_SUCCESS(res, res);

     nsCOMPtr<nsIDOMNode> brNode;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->CreateBR(blockParent, blockLen, address_of(brNode));

     NS_ENSURE_SUCCESS(res, res);

   }

   nsCOMPtr<nsIDOMNode> listItem = IsInListItem(blockParent);

   if (listItem && listItem != hostNode) {

     ReturnInListItem(aSelection, listItem, node, offset);

     *aHandled = true;

     return NS_OK;

   } else if (nsHTMLEditUtils::IsHeader(blockParent)) {

     // headers: close (or split) header

     ReturnInHeader(aSelection, blockParent, node, offset);

     *aHandled = true;

     return NS_OK;

   } else if (nsHTMLEditUtils::IsParagraph(blockParent)) {

     // paragraphs: special rules to look for <br>s

     res = ReturnInParagraph(aSelection, blockParent, node, offset,

                             aCancel, aHandled);

     NS_ENSURE_SUCCESS(res, res);

     // fall through, we may not have handled it in ReturnInParagraph()

   }

   // if not already handled then do the standard thing

   if (!(*aHandled)) {

     *aHandled = true;

     return StandardBreakImpl(node, offset, aSelection);

   }

   return NS_OK;

 }

 nsresult

 nsHTMLEditRules::StandardBreakImpl(nsIDOMNode* aNode, int32_t aOffset,

                                    nsISelection* aSelection)

 {

   nsCOMPtr<nsIDOMNode> brNode;

   bool bAfterBlock = false;

   bool bBeforeBlock = false;

   nsresult res = NS_OK;

   nsCOMPtr<nsIDOMNode> node(aNode);

   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(aSelection));

   if (IsPlaintextEditor()) {

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->CreateBR(node, aOffset, address_of(brNode));

   } else {

     NS_ENSURE_STATE(mHTMLEditor);

     nsWSRunObject wsObj(mHTMLEditor, node, aOffset);

     nsCOMPtr<nsIDOMNode> visNode, linkNode;

     int32_t visOffset = 0, newOffset;

     WSType wsType;

     wsObj.PriorVisibleNode(node, aOffset, address_of(visNode),

                            &visOffset, &wsType);

     if (wsType & WSType::block) {

       bAfterBlock = true;

     }

     wsObj.NextVisibleNode(node, aOffset, address_of(visNode),

                           &visOffset, &wsType);

     if (wsType & WSType::block) {

       bBeforeBlock = true;

     }

     NS_ENSURE_STATE(mHTMLEditor);

     if (mHTMLEditor->IsInLink(node, address_of(linkNode))) {

       // split the link

       nsCOMPtr<nsIDOMNode> linkParent;

       res = linkNode->GetParentNode(getter_AddRefs(linkParent));

       NS_ENSURE_SUCCESS(res, res);

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->SplitNodeDeep(linkNode, node, aOffset,

                                        &newOffset, true);

       NS_ENSURE_SUCCESS(res, res);

       // reset {node,aOffset} to the point where link was split

       node = linkParent;

       aOffset = newOffset;

     }

     res = wsObj.InsertBreak(address_of(node), &aOffset,

                             address_of(brNode), nsIEditor::eNone);

   }

   NS_ENSURE_SUCCESS(res, res);

   node = nsEditor::GetNodeLocation(brNode, &aOffset);

   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);

   if (bAfterBlock && bBeforeBlock) {

     // we just placed a br 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.

     selPriv->SetInterlinePosition(true);

     res = aSelection->Collapse(node, aOffset);

   } else {

     NS_ENSURE_STATE(mHTMLEditor);

     nsWSRunObject wsObj(mHTMLEditor, node, aOffset+1);

     nsCOMPtr<nsIDOMNode> secondBR;

     int32_t visOffset = 0;

     WSType wsType;

     wsObj.NextVisibleNode(node, aOffset+1, address_of(secondBR),

                           &visOffset, &wsType);

     if (wsType == WSType::br) {

       // the next thing after the break we inserted is another break.  Move

       // the 2nd break to be the first breaks 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.

       int32_t brOffset;

       nsCOMPtr<nsIDOMNode> brParent = nsEditor::GetNodeLocation(secondBR, &brOffset);

       if (brParent != node || brOffset != aOffset + 1) {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->MoveNode(secondBR, node, aOffset+1);

         NS_ENSURE_SUCCESS(res, res);

       }

     }

     // 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.

     nsCOMPtr<nsIDOMNode> siblingNode;

     brNode->GetNextSibling(getter_AddRefs(siblingNode));

     if (siblingNode && IsBlockNode(siblingNode)) {

       selPriv->SetInterlinePosition(false);

     } else {

       selPriv->SetInterlinePosition(true);

     }

     res = aSelection->Collapse(node, aOffset+1);

   }

   return res;

 }

 nsresult

 nsHTMLEditRules::DidInsertBreak(nsISelection *aSelection, nsresult aResult)

 {

   return NS_OK;

 }

 nsresult

 nsHTMLEditRules::SplitMailCites(nsISelection *aSelection, bool aPlaintext, bool *aHandled)

 {

   NS_ENSURE_TRUE(aSelection && aHandled, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(aSelection));

   nsCOMPtr<nsIDOMNode> citeNode, selNode, leftCite, rightCite;

   int32_t selOffset, newOffset;

   NS_ENSURE_STATE(mHTMLEditor);

   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);

   NS_ENSURE_SUCCESS(res, res);

   res = GetTopEnclosingMailCite(selNode, address_of(citeNode), aPlaintext);

   NS_ENSURE_SUCCESS(res, res);

   if (citeNode)

   {

     // 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.

     NS_ENSURE_STATE(mHTMLEditor);

     nsWSRunObject wsObj(mHTMLEditor, selNode, selOffset);

     nsCOMPtr<nsIDOMNode> visNode;

     int32_t visOffset=0;

     WSType wsType;

     wsObj.NextVisibleNode(selNode, selOffset, address_of(visNode),

                           &visOffset, &wsType);

     if (wsType == WSType::br) {

       // ok, we are just before a break.  is it inside the mailquote?

       int32_t unused;

       if (nsEditorUtils::IsDescendantOf(visNode, citeNode, &unused))

       {

         // it is.  so lets reset our selection to be just after it.

         NS_ENSURE_STATE(mHTMLEditor);

         selNode = mHTMLEditor->GetNodeLocation(visNode, &selOffset);

         ++selOffset;

       }

     }

     nsCOMPtr<nsIDOMNode> brNode;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->SplitNodeDeep(citeNode, selNode, selOffset, &newOffset, 

                        true, address_of(leftCite), address_of(rightCite));

     NS_ENSURE_SUCCESS(res, res);

     res = citeNode->GetParentNode(getter_AddRefs(selNode));

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->CreateBR(selNode, newOffset, address_of(brNode));

     NS_ENSURE_SUCCESS(res, res);

     // want selection before the break, and on same line

     selPriv->SetInterlinePosition(true);

     res = aSelection->Collapse(selNode, newOffset);

     NS_ENSURE_SUCCESS(res, res);

     // 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 (IsInlineNode(citeNode))

     {

       NS_ENSURE_STATE(mHTMLEditor);

       nsWSRunObject wsObj(mHTMLEditor, selNode, newOffset);

       nsCOMPtr<nsIDOMNode> visNode;

       int32_t visOffset=0;

       WSType wsType;

       wsObj.PriorVisibleNode(selNode, newOffset, address_of(visNode),

                              &visOffset, &wsType);

       if (wsType == WSType::normalWS || wsType == WSType::text ||

           wsType == WSType::special) {

         NS_ENSURE_STATE(mHTMLEditor);

         nsWSRunObject wsObjAfterBR(mHTMLEditor, selNode, newOffset+1);

         wsObjAfterBR.NextVisibleNode(selNode, newOffset+1, address_of(visNode),

                                      &visOffset, &wsType);

         if (wsType == WSType::normalWS || wsType == WSType::text ||

             wsType == WSType::special) {

           NS_ENSURE_STATE(mHTMLEditor);

           res = mHTMLEditor->CreateBR(selNode, newOffset, address_of(brNode));

           NS_ENSURE_SUCCESS(res, res);

         }

       }

     }

     // delete any empty cites

     bool bEmptyCite = false;

     if (leftCite)

     {

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->IsEmptyNode(leftCite, &bEmptyCite, true, false);

       if (NS_SUCCEEDED(res) && bEmptyCite) {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->DeleteNode(leftCite);

       }

       NS_ENSURE_SUCCESS(res, res);

     }

     if (rightCite)

     {

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->IsEmptyNode(rightCite, &bEmptyCite, true, false);

       if (NS_SUCCEEDED(res) && bEmptyCite) {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->DeleteNode(rightCite);

       }

       NS_ENSURE_SUCCESS(res, res);

     }

     *aHandled = true;

   }

   return NS_OK;

 }

 nsresult

 nsHTMLEditRules::WillDeleteSelection(Selection* aSelection,

                                      nsIEditor::EDirection aAction,

                                      nsIEditor::EStripWrappers aStripWrappers,

                                      bool* aCancel,

                                      bool* aHandled)

 {

   MOZ_ASSERT(aStripWrappers == nsIEditor::eStrip ||

              aStripWrappers == nsIEditor::eNoStrip);

   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }

   // initialize out param

   *aCancel = false;

   *aHandled = false;

   // remember that we did a selection deletion.  Used by CreateStyleForInsertText()

   mDidDeleteSelection = true;

   // if there is only bogus content, cancel the operation

   if (mBogusNode) 

   {

     *aCancel = true;

     return NS_OK;

   }

   bool bCollapsed = aSelection->Collapsed(), join = false;

   // origCollapsed is used later to determine whether we should join 

   // blocks. We don't really care about bCollapsed because it will be 

   // modified by ExtendSelectionForDelete later. JoinBlocks should 

   // happen if the original selection is collapsed and the cursor is 

   // at the end of a block element, in which case ExtendSelectionForDelete 

   // would always make the selection not collapsed.

   bool origCollapsed = bCollapsed;

   nsCOMPtr<nsIDOMNode> startNode, selNode;

   int32_t startOffset, selOffset;

   // first check for table selection mode.  If so,

   // hand off to table editor.

   nsCOMPtr<nsIDOMElement> cell;

   NS_ENSURE_STATE(mHTMLEditor);

   nsresult res = mHTMLEditor->GetFirstSelectedCell(nullptr, getter_AddRefs(cell));

   if (NS_SUCCEEDED(res) && cell) {

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->DeleteTableCellContents();

     *aHandled = true;

     return res;

   }

   cell = nullptr;

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);

   if (bCollapsed)

   {

     // if we are inside an empty block, delete it.

     NS_ENSURE_STATE(mHTMLEditor);

     nsCOMPtr<nsIContent> hostContent = mHTMLEditor->GetActiveEditingHost();

     nsCOMPtr<nsIDOMNode> hostNode = do_QueryInterface(hostContent);

     NS_ENSURE_TRUE(hostNode, NS_ERROR_FAILURE);

     res = CheckForEmptyBlock(startNode, hostNode, aSelection, aHandled);

     NS_ENSURE_SUCCESS(res, res);

     if (*aHandled) return NS_OK;

     // Test for distance between caret and text that will be deleted

     res = CheckBidiLevelForDeletion(aSelection, startNode, startOffset, aAction, aCancel);

     NS_ENSURE_SUCCESS(res, res);

     if (*aCancel) return NS_OK;

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->ExtendSelectionForDelete(aSelection, &aAction);

     NS_ENSURE_SUCCESS(res, res);

     // We should delete nothing.

     if (aAction == nsIEditor::eNone)

       return NS_OK;

     // ExtendSelectionForDelete() may have changed the selection, update it

     NS_ENSURE_STATE(mHTMLEditor);

     res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);

     bCollapsed = aSelection->Collapsed();

   }

   if (bCollapsed)

   {

     // what's in the direction we are deleting?

     NS_ENSURE_STATE(mHTMLEditor);

     nsWSRunObject wsObj(mHTMLEditor, startNode, startOffset);

     nsCOMPtr<nsIDOMNode> visNode;

     int32_t visOffset;

     WSType wsType;

     // find next visible node

     if (aAction == nsIEditor::eNext)

       wsObj.NextVisibleNode(startNode, startOffset, address_of(visNode),

                             &visOffset, &wsType);

     else

       wsObj.PriorVisibleNode(startNode, startOffset, address_of(visNode),

                              &visOffset, &wsType);

     if (!visNode) // can't find anything to delete!

     {

       *aCancel = true;

       return res;

     }

     if (wsType == WSType::normalWS) {

       // we found some visible ws to delete.  Let ws code handle it.

       if (aAction == nsIEditor::eNext)

         res = wsObj.DeleteWSForward();

       else

         res = wsObj.DeleteWSBackward();

       *aHandled = true;

       NS_ENSURE_SUCCESS(res, res);

       res = InsertBRIfNeeded(aSelection);

       return res;

     } else if (wsType == WSType::text) {

       // found normal text to delete.  

       int32_t so = visOffset;

       int32_t eo = visOffset+1;

       if (aAction == nsIEditor::ePrevious) 

       { 

         if (so == 0) return NS_ERROR_UNEXPECTED;

         so--; 

         eo--; 

       }

       else

       {

         nsCOMPtr<nsIDOMRange> range;

         res = aSelection->GetRangeAt(0, getter_AddRefs(range));

         NS_ENSURE_SUCCESS(res, res);

 #ifdef DEBUG

         nsIDOMNode *container;

         res = range->GetStartContainer(&container);

         NS_ENSURE_SUCCESS(res, res);

         NS_ASSERTION(container == visNode, "selection start not in visNode");

         res = range->GetEndContainer(&container);

         NS_ENSURE_SUCCESS(res, res);

         NS_ASSERTION(container == visNode, "selection end not in visNode");

 #endif

         res = range->GetStartOffset(&so);

         NS_ENSURE_SUCCESS(res, res);

         res = range->GetEndOffset(&eo);

         NS_ENSURE_SUCCESS(res, res);

       }

       NS_ENSURE_STATE(mHTMLEditor);

       res = nsWSRunObject::PrepareToDeleteRange(mHTMLEditor, address_of(visNode), &so, address_of(visNode), &eo);

       NS_ENSURE_SUCCESS(res, res);

       nsCOMPtr<nsIDOMCharacterData> nodeAsText(do_QueryInterface(visNode));

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->DeleteText(nodeAsText, std::min(so, eo), DeprecatedAbs(eo - so));

       *aHandled = true;

       NS_ENSURE_SUCCESS(res, res);    

       res = InsertBRIfNeeded(aSelection);

       return res;

     } else if (wsType == WSType::special || wsType == WSType::br ||

                nsHTMLEditUtils::IsHR(visNode)) {

       // short circuit for invisible breaks.  delete them and recurse.

       if (nsTextEditUtils::IsBreak(visNode) &&

           (!mHTMLEditor || !mHTMLEditor->IsVisBreak(visNode)))

       {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->DeleteNode(visNode);

         NS_ENSURE_SUCCESS(res, res);

         return WillDeleteSelection(aSelection, aAction, aStripWrappers,

                                    aCancel, aHandled);

       }

       // special handling for backspace when positioned after <hr>

       if (aAction == nsIEditor::ePrevious && nsHTMLEditUtils::IsHR(visNode))

       {

         /*

           Only if the caret is positioned at the end-of-hr-line position,

           we want to delete the <hr>.

           In other words, we only want to delete, if

           our selection position (indicated by startNode and startOffset)

           is the position directly after the <hr>,

           on the same line as the <hr>.

           To detect this case we check:

           startNode == parentOfVisNode

           and

           startOffset -1 == visNodeOffsetToVisNodeParent

           and

           interline position is false (left)

           In any other case we set the position to 

           startnode -1 and interlineposition to false,

           only moving the caret to the end-of-hr-line position.

         */

         bool moveOnly = true;

         selNode = nsEditor::GetNodeLocation(visNode, &selOffset);

         bool interLineIsRight;

         res = aSelection->GetInterlinePosition(&interLineIsRight);

         NS_ENSURE_SUCCESS(res, res);

         if (startNode == selNode &&

             startOffset -1 == selOffset &&

             !interLineIsRight)

         {

           moveOnly = false;

         }

         if (moveOnly)

         {

           // Go to the position after the <hr>, but to the end of the <hr> line

           // by setting the interline position to left.

           ++selOffset;

           res = aSelection->Collapse(selNode, selOffset);

           aSelection->SetInterlinePosition(false);

           mDidExplicitlySetInterline = true;

           *aHandled = true;

           // There is one exception to the move only case.

           // If the <hr> is followed by a <br> we want to delete the <br>.

           WSType otherWSType;

           nsCOMPtr<nsIDOMNode> otherNode;

           int32_t otherOffset;

           wsObj.NextVisibleNode(startNode, startOffset, address_of(otherNode),

                                 &otherOffset, &otherWSType);

           if (otherWSType == WSType::br) {

             // Delete the <br>

             NS_ENSURE_STATE(mHTMLEditor);

             res = nsWSRunObject::PrepareToDeleteNode(mHTMLEditor, otherNode);

             NS_ENSURE_SUCCESS(res, res);

             NS_ENSURE_STATE(mHTMLEditor);

             res = mHTMLEditor->DeleteNode(otherNode);

             NS_ENSURE_SUCCESS(res, res);

           }

           return NS_OK;

         }

         // else continue with normal delete code

       }

       // found break or image, or hr.  

       NS_ENSURE_STATE(mHTMLEditor);

       res = nsWSRunObject::PrepareToDeleteNode(mHTMLEditor, visNode);

       NS_ENSURE_SUCCESS(res, res);

       // remember sibling to visnode, if any

       nsCOMPtr<nsIDOMNode> sibling, stepbrother;

       NS_ENSURE_STATE(mHTMLEditor);

       mHTMLEditor->GetPriorHTMLSibling(visNode, address_of(sibling));

       // delete the node, and join like nodes if appropriate

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->DeleteNode(visNode);

       NS_ENSURE_SUCCESS(res, res);

       // we did something, so lets say so.

       *aHandled = true;

       // is there a prior node and are they siblings?

       if (sibling) {

         NS_ENSURE_STATE(mHTMLEditor);

         mHTMLEditor->GetNextHTMLSibling(sibling, address_of(stepbrother));

       }

       if (startNode == stepbrother) 

       {

         // are they both text nodes?

         NS_ENSURE_STATE(mHTMLEditor);

         if (mHTMLEditor->IsTextNode(startNode) &&

             (!mHTMLEditor || mHTMLEditor->IsTextNode(sibling)))

         {

           NS_ENSURE_STATE(mHTMLEditor);

           // if so, join them!

           res = JoinNodesSmart(sibling, startNode, address_of(selNode), &selOffset);

           NS_ENSURE_SUCCESS(res, res);

           // fix up selection

           res = aSelection->Collapse(selNode, selOffset);

         }

       }

       NS_ENSURE_SUCCESS(res, res);    

       res = InsertBRIfNeeded(aSelection);

       return res;

     } else if (wsType == WSType::otherBlock) {

       // make sure it's not a table element.  If so, cancel the operation 

       // (translation: users cannot backspace or delete across table cells)

       if (nsHTMLEditUtils::IsTableElement(visNode))

       {

         *aCancel = true;

         return NS_OK;

       }

       // next to a block.  See if we are between a block and a br.  If so, we really

       // want to delete the br.  Else join content at selection to the block.

       bool bDeletedBR = false;

       WSType otherWSType;

       nsCOMPtr<nsIDOMNode> otherNode;

       int32_t otherOffset;

       // find node in other direction

       if (aAction == nsIEditor::eNext)

         wsObj.PriorVisibleNode(startNode, startOffset, address_of(otherNode),

                                &otherOffset, &otherWSType);

       else

         wsObj.NextVisibleNode(startNode, startOffset, address_of(otherNode),

                               &otherOffset, &otherWSType);

       // first find the adjacent node in the block

       nsCOMPtr<nsIDOMNode> leafNode, leftNode, rightNode;

       if (aAction == nsIEditor::ePrevious) 

       {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->GetLastEditableLeaf( visNode, address_of(leafNode));

         NS_ENSURE_SUCCESS(res, res);

         leftNode = leafNode;

         rightNode = startNode;

       }

       else

       {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->GetFirstEditableLeaf( visNode, address_of(leafNode));

         NS_ENSURE_SUCCESS(res, res);

         leftNode = startNode;

         rightNode = leafNode;

       }

       if (nsTextEditUtils::IsBreak(otherNode))

       {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->DeleteNode(otherNode);

         NS_ENSURE_SUCCESS(res, res);

         *aHandled = true;

         bDeletedBR = true;

       }

       // don't cross table boundaries

       if (leftNode && rightNode && InDifferentTableElements(leftNode, rightNode)) {

         return NS_OK;

       }

       if (bDeletedBR)

       {

         // put selection at edge of block and we are done.

         nsCOMPtr<nsIDOMNode> newSelNode;

         int32_t newSelOffset;

         res = GetGoodSelPointForNode(leafNode, aAction, address_of(newSelNode), &newSelOffset);

         NS_ENSURE_SUCCESS(res, res);

         aSelection->Collapse(newSelNode, newSelOffset);

         return res;

       }

       // else we are joining content to block

       nsCOMPtr<nsIDOMNode> selPointNode = startNode;

       int32_t selPointOffset = startOffset;

       {

         NS_ENSURE_STATE(mHTMLEditor);

         nsAutoTrackDOMPoint tracker(mHTMLEditor->mRangeUpdater, address_of(selPointNode), &selPointOffset);

         res = JoinBlocks(leftNode, rightNode, aCancel);

         *aHandled = true;

         NS_ENSURE_SUCCESS(res, res);

       }

       aSelection->Collapse(selPointNode, selPointOffset);

       return res;

     } else if (wsType == WSType::thisBlock) {

       // at edge of our block.  Look beside it and see if we can join to an adjacent block

       // make sure it's not a table element.  If so, cancel the operation 

       // (translation: users cannot backspace or delete across table cells)

       if (nsHTMLEditUtils::IsTableElement(visNode))

       {

         *aCancel = true;

         return NS_OK;

       }

       // first find the relavent nodes

       nsCOMPtr<nsIDOMNode> leftNode, rightNode;

       if (aAction == nsIEditor::ePrevious) 

       {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->GetPriorHTMLNode(visNode, address_of(leftNode));

         NS_ENSURE_SUCCESS(res, res);

         rightNode = startNode;

       }

       else

       {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->GetNextHTMLNode( visNode, address_of(rightNode));

         NS_ENSURE_SUCCESS(res, res);

         leftNode = startNode;

       }

       // nothing to join

       if (!leftNode || !rightNode)

       {

         *aCancel = true;

         return NS_OK;

       }

       // don't cross table boundaries -- cancel it

       if (InDifferentTableElements(leftNode, rightNode)) {

         *aCancel = true;

         return NS_OK;

       }

       nsCOMPtr<nsIDOMNode> selPointNode = startNode;

       int32_t selPointOffset = startOffset;

       {

         NS_ENSURE_STATE(mHTMLEditor);

         nsAutoTrackDOMPoint tracker(mHTMLEditor->mRangeUpdater, address_of(selPointNode), &selPointOffset);

         res = JoinBlocks(leftNode, rightNode, aCancel);

         *aHandled = true;

         NS_ENSURE_SUCCESS(res, res);

       }

       aSelection->Collapse(selPointNode, selPointOffset);

       return res;

     }

   }

   // else we have a non collapsed selection

   // first adjust the selection

   res = ExpandSelectionForDeletion(aSelection);

   NS_ENSURE_SUCCESS(res, res);

   // remember that we did a ranged delete for the benefit of AfterEditInner().

   mDidRangedDelete = true;

   // refresh start and end points

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);

   nsCOMPtr<nsIDOMNode> endNode;

   int32_t endOffset;

   NS_ENSURE_STATE(mHTMLEditor);

   res = mHTMLEditor->GetEndNodeAndOffset(aSelection, getter_AddRefs(endNode), &endOffset);

   NS_ENSURE_SUCCESS(res, res); 

   NS_ENSURE_TRUE(endNode, NS_ERROR_FAILURE);

   // figure out if the endpoints are in nodes that can be merged  

   // adjust surrounding whitespace in preperation to delete selection

   if (!IsPlaintextEditor())

   {

     NS_ENSURE_STATE(mHTMLEditor);

     nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);

     res = nsWSRunObject::PrepareToDeleteRange(mHTMLEditor,

                                             address_of(startNode), &startOffset, 

                                             address_of(endNode), &endOffset);

     NS_ENSURE_SUCCESS(res, res); 

   }

   {

     // track location of where we are deleting

     NS_ENSURE_STATE(mHTMLEditor);

     nsAutoTrackDOMPoint startTracker(mHTMLEditor->mRangeUpdater,

                                      address_of(startNode), &startOffset);

     nsAutoTrackDOMPoint endTracker(mHTMLEditor->mRangeUpdater,

                                    address_of(endNode), &endOffset);

     // we are handling all ranged deletions directly now.

     *aHandled = true;

     if (endNode == startNode)

     {

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);

       NS_ENSURE_SUCCESS(res, res); 

     }

     else

     {

       // figure out mailcite ancestors

       nsCOMPtr<nsIDOMNode> endCiteNode, startCiteNode;

       res = GetTopEnclosingMailCite(startNode, address_of(startCiteNode), 

                                     IsPlaintextEditor());

       NS_ENSURE_SUCCESS(res, res); 

       res = GetTopEnclosingMailCite(endNode, address_of(endCiteNode), 

                                     IsPlaintextEditor());

       NS_ENSURE_SUCCESS(res, res); 

       // if we only have a mailcite at one of the two endpoints, set the directionality

       // of the deletion so that the selection will end up outside the mailcite.

       if (startCiteNode && !endCiteNode)

       {

         aAction = nsIEditor::eNext;

       }

       else if (!startCiteNode && endCiteNode)

       {

         aAction = nsIEditor::ePrevious;

       }

       // figure out block parents

       nsCOMPtr<nsIDOMNode> leftParent;

       nsCOMPtr<nsIDOMNode> rightParent;

       if (IsBlockNode(startNode))

         leftParent = startNode;

       else {

         NS_ENSURE_STATE(mHTMLEditor);

         leftParent = mHTMLEditor->GetBlockNodeParent(startNode);

       }

       if (IsBlockNode(endNode))

         rightParent = endNode;

       else {

         NS_ENSURE_STATE(mHTMLEditor);

         rightParent = mHTMLEditor->GetBlockNodeParent(endNode);

       }

       // are endpoint block parents the same?  use default deletion

       if (leftParent == rightParent) 

       {

         NS_ENSURE_STATE(mHTMLEditor);

         res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);

       }

       else

       {

         // deleting across blocks

         // are the blocks of same type?

         NS_ENSURE_STATE(leftParent && rightParent);

         // are the blocks siblings?

         nsCOMPtr<nsIDOMNode> leftBlockParent;

         nsCOMPtr<nsIDOMNode> rightBlockParent;

         leftParent->GetParentNode(getter_AddRefs(leftBlockParent));

         rightParent->GetParentNode(getter_AddRefs(rightBlockParent));

         // MOOSE: this could conceivably screw up a table.. fix me.

         if (   (leftBlockParent == rightBlockParent)

             && (!mHTMLEditor || mHTMLEditor->NodesSameType(leftParent, rightParent))  )

         {

           NS_ENSURE_STATE(mHTMLEditor);

           if (nsHTMLEditUtils::IsParagraph(leftParent))

           {

             // first delete the selection

             NS_ENSURE_STATE(mHTMLEditor);

             res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);

             NS_ENSURE_SUCCESS(res, res);

             // then join para's, insert break

             NS_ENSURE_STATE(mHTMLEditor);

             res = mHTMLEditor->JoinNodeDeep(leftParent,rightParent,address_of(selNode),&selOffset);

             NS_ENSURE_SUCCESS(res, res);

             // fix up selection

             res = aSelection->Collapse(selNode,selOffset);

             return res;

           }

           if (nsHTMLEditUtils::IsListItem(leftParent)

               || nsHTMLEditUtils::IsHeader(leftParent))

           {

             // first delete the selection

             NS_ENSURE_STATE(mHTMLEditor);

             res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);

             NS_ENSURE_SUCCESS(res, res);

             // join blocks

             NS_ENSURE_STATE(mHTMLEditor);

             res = mHTMLEditor->JoinNodeDeep(leftParent,rightParent,address_of(selNode),&selOffset);

             NS_ENSURE_SUCCESS(res, res);

             // fix up selection

             res = aSelection->Collapse(selNode,selOffset);

             return res;

           }

         }

         // else blocks not same type, or not siblings.  Delete everything except

         // table elements.

         join = true;

         uint32_t rangeCount = aSelection->GetRangeCount();

         for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {

           nsRefPtr<nsRange> range = aSelection->GetRangeAt(rangeIdx);

           // build a list of nodes in the range

           nsCOMArray<nsIDOMNode> arrayOfNodes;

           nsTrivialFunctor functor;

           nsDOMSubtreeIterator iter;

           res = iter.Init(range);

           NS_ENSURE_SUCCESS(res, res);

           res = iter.AppendList(functor, arrayOfNodes);

           NS_ENSURE_SUCCESS(res, res);

           // now that we have the list, delete non table elements

           int32_t listCount = arrayOfNodes.Count();

           for (int32_t j = 0; j < listCount; j++) {

             nsCOMPtr<nsINode> somenode = do_QueryInterface(arrayOfNodes[0]);

             NS_ENSURE_STATE(somenode);

             DeleteNonTableElements(somenode);

             arrayOfNodes.RemoveObjectAt(0);

             // If something visible is deleted, no need to join.

             // Visible means all nodes except non-visible textnodes and breaks.

             if (join && origCollapsed) {

               if (!somenode->IsContent()) {

                 join = false;

                 continue;

               }

               nsCOMPtr<nsIContent> content = somenode->AsContent();

               if (content->NodeType() == nsIDOMNode::TEXT_NODE) {

                 NS_ENSURE_STATE(mHTMLEditor);

                 mHTMLEditor->IsVisTextNode(content, &join, true);

               } else {

                 NS_ENSURE_STATE(mHTMLEditor);

                 join = content->IsHTML(nsGkAtoms::br) &&

                        !mHTMLEditor->IsVisBreak(somenode->AsDOMNode());

               }

             }

           }

         }

         // check endopints for possible text deletion.

         // we can assume that if text node is found, we can

         // delete to end or to begining as appropriate,

         // since the case where both sel endpoints in same

         // text node was already handled (we wouldn't be here)

         NS_ENSURE_STATE(mHTMLEditor);

         if ( mHTMLEditor->IsTextNode(startNode) )

         {

           // delete to last character

           nsCOMPtr<nsIDOMCharacterData>nodeAsText;

           uint32_t len;

           nodeAsText = do_QueryInterface(startNode);

           nodeAsText->GetLength(&len);

           if (len > (uint32_t)startOffset)

           {

             NS_ENSURE_STATE(mHTMLEditor);

             res = mHTMLEditor->DeleteText(nodeAsText,startOffset,len-startOffset);

             NS_ENSURE_SUCCESS(res, res);

           }

         }

         NS_ENSURE_STATE(mHTMLEditor);

         if ( mHTMLEditor->IsTextNode(endNode) )

         {

           // delete to first character

           nsCOMPtr<nsIDOMCharacterData>nodeAsText;

           nodeAsText = do_QueryInterface(endNode);

           if (endOffset)

           {

             NS_ENSURE_STATE(mHTMLEditor);

             res = mHTMLEditor->DeleteText(nodeAsText,0,endOffset);

             NS_ENSURE_SUCCESS(res, res);

           }

         }

         if (join) {

           res = JoinBlocks(leftParent, rightParent, aCancel);

           NS_ENSURE_SUCCESS(res, res);

         }

       }

     }

   }

   //If we're joining blocks: if deleting forward the selection should be 

   //collapsed to the end of the selection, if deleting backward the selection 

   //should be collapsed to the beginning of the selection. But if we're not 

   //joining then the selection should collapse to the beginning of the 

   //selection if we'redeleting forward, because the end of the selection will 

   //still be in the next block. And same thing for deleting backwards 

   //(selection should collapse to the end, because the beginning will still 

   //be in the first block). See Bug 507936

   if (join ? aAction == nsIEditor::eNext : aAction == nsIEditor::ePrevious)

   {

     res = aSelection->Collapse(endNode,endOffset);

   }

   else

   {

     res = aSelection->Collapse(startNode,startOffset);

   }

   return res;

 }  

 /*****************************************************************************************************

 *    InsertBRIfNeeded: determines if a br is needed for current selection to not be spastic.

 *    If so, it inserts one.  Callers responsibility to only call with collapsed selection.

 *         nsISelection *aSelection      the collapsed selection 

 */

 nsresult

 nsHTMLEditRules::InsertBRIfNeeded(nsISelection *aSelection)

 {

   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);

   // get selection  

   nsCOMPtr<nsIDOMNode> node;

   int32_t offset;

   nsresult res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(node), &offset);

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);

   // inline elements don't need any br

   if (!IsBlockNode(node))

     return res;

   // examine selection

   NS_ENSURE_STATE(mHTMLEditor);

   nsWSRunObject wsObj(mHTMLEditor, node, offset);

   if (((wsObj.mStartReason & WSType::block) ||

        (wsObj.mStartReason & WSType::br)) &&

       (wsObj.mEndReason & WSType::block)) {

     // if we are tucked between block boundaries then insert a br

     // first check that we are allowed to

     NS_ENSURE_STATE(mHTMLEditor);

     if (mHTMLEditor->CanContainTag(node, nsGkAtoms::br)) {

       nsCOMPtr<nsIDOMNode> brNode;

       NS_ENSURE_STATE(mHTMLEditor);

       res = mHTMLEditor->CreateBR(node, offset, address_of(brNode), nsIEditor::ePrevious);

     }

   }

   return res;

 }

 /*****************************************************************************************************

 *    GetGoodSelPointForNode: Finds where at a node you would want to set the selection if you were

 *    trying to have a caret next to it.

 *         nsIDOMNode *aNode                  the node 

 *         nsIEditor::EDirection aAction      which edge to find: eNext indicates beginning, ePrevious ending

 *         nsCOMPtr<nsIDOMNode> *outSelNode   desired sel node

 *         int32_t *outSelOffset              desired sel offset

 */

 nsresult

 nsHTMLEditRules::GetGoodSelPointForNode(nsIDOMNode *aNode, nsIEditor::EDirection aAction, 

                                         nsCOMPtr<nsIDOMNode> *outSelNode, int32_t *outSelOffset)

 {

   NS_ENSURE_TRUE(aNode && outSelNode && outSelOffset, NS_ERROR_NULL_POINTER);

   nsresult res = NS_OK;

   // default values

   *outSelNode = aNode;

   *outSelOffset = 0;

   NS_ENSURE_STATE(mHTMLEditor);

   if (mHTMLEditor->IsTextNode(aNode) ||

       !mHTMLEditor || mHTMLEditor->IsContainer(aNode))

   {

     NS_ENSURE_STATE(mHTMLEditor);

     if (aAction == nsIEditor::ePrevious)

     {

       uint32_t len;

       res = mHTMLEditor->GetLengthOfDOMNode(aNode, len);

       *outSelOffset = int32_t(len);

       NS_ENSURE_SUCCESS(res, res);

     }

   }

   else 

   {

     *outSelNode = nsEditor::GetNodeLocation(aNode, outSelOffset);

     if (!nsTextEditUtils::IsBreak(aNode) ||

         !mHTMLEditor || mHTMLEditor->IsVisBreak(aNode))

     {

       NS_ENSURE_STATE(mHTMLEditor);

       if (aAction == nsIEditor::ePrevious)

         (*outSelOffset)++;

     }

   }

   return res;