The Tor Browser / file revision

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

 /* 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 "mozilla/DebugOnly.h"

 #include "mozilla/EventStates.h"

 #include "mozilla/TextEvents.h"

 #include "nsCRT.h"

 #include "nsUnicharUtils.h"

 #include "nsHTMLEditor.h"

 #include "nsHTMLEditRules.h"

 #include "nsTextEditUtils.h"

 #include "nsHTMLEditUtils.h"

 #include "nsHTMLEditorEventListener.h"

 #include "TypeInState.h"

 #include "nsHTMLURIRefObject.h"

 #include "nsIDOMText.h"

 #include "nsIDOMMozNamedAttrMap.h"

 #include "nsIDOMNodeList.h"

 #include "nsIDOMDocument.h"

 #include "nsIDOMAttr.h"

 #include "nsIDocumentInlines.h"

 #include "nsIDOMEventTarget.h" 

 #include "nsIDOMKeyEvent.h"

 #include "nsIDOMMouseEvent.h"

 #include "nsIDOMHTMLAnchorElement.h"

 #include "nsISelectionController.h"

 #include "nsIDOMHTMLDocument.h"

 #include "nsILinkHandler.h"

 #include "nsIInlineSpellChecker.h"

 #include "mozilla/css/Loader.h"

 #include "nsCSSStyleSheet.h"

 #include "nsIDOMStyleSheet.h"

 #include "nsIContent.h"

 #include "nsIContentIterator.h"

 #include "nsIDOMRange.h"

 #include "nsISupportsArray.h"

 #include "nsContentUtils.h"

 #include "nsIDocumentEncoder.h"

 #include "nsIDOMDocumentFragment.h"

 #include "nsIPresShell.h"

 #include "nsPresContext.h"

 #include "SetDocTitleTxn.h"

 #include "nsFocusManager.h"

 #include "nsPIDOMWindow.h"

 // netwerk

 #include "nsIURI.h"

 #include "nsNetUtil.h"

 // Transactionas

 #include "nsStyleSheetTxns.h"

 // Misc

 #include "TextEditorTest.h"

 #include "nsEditorUtils.h"

 #include "nsWSRunObject.h"

 #include "nsGkAtoms.h"

 #include "nsIWidget.h"

 #include "nsIFrame.h"

 #include "nsIParserService.h"

 #include "mozilla/dom/Selection.h"

 #include "mozilla/dom/Element.h"

 #include "mozilla/dom/EventTarget.h"

 #include "mozilla/dom/HTMLBodyElement.h"

 #include "nsTextFragment.h"

 using namespace mozilla;

 using namespace mozilla::dom;

 using namespace mozilla::widget;

 // Some utilities to handle annoying overloading of "A" tag for link and named anchor

 static char hrefText[] = "href";

 static char anchorTxt[] = "anchor";

 static char namedanchorText[] = "namedanchor";

 #define IsLinkTag(s) (s.EqualsIgnoreCase(hrefText))

 #define IsNamedAnchorTag(s) (s.EqualsIgnoreCase(anchorTxt) || s.EqualsIgnoreCase(namedanchorText))

 nsHTMLEditor::nsHTMLEditor()

 : nsPlaintextEditor()

 , mCRInParagraphCreatesParagraph(false)

 , mSelectedCellIndex(0)

 , mIsObjectResizingEnabled(true)

 , mIsResizing(false)

 , mIsAbsolutelyPositioningEnabled(true)

 , mResizedObjectIsAbsolutelyPositioned(false)

 , mGrabberClicked(false)

 , mIsMoving(false)

 , mSnapToGridEnabled(false)

 , mIsInlineTableEditingEnabled(true)

 , mInfoXIncrement(20)

 , mInfoYIncrement(20)

 , mGridSize(0)

 {

 } 

 nsHTMLEditor::~nsHTMLEditor()

 {

   // remove the rules as an action listener.  Else we get a bad

   // ownership loop later on.  it's ok if the rules aren't a listener;

   // we ignore the error.

   nsCOMPtr<nsIEditActionListener> mListener = do_QueryInterface(mRules);

   RemoveEditActionListener(mListener);

   //the autopointers will clear themselves up. 

   //but we need to also remove the listeners or we have a leak

   nsCOMPtr<nsISelection>selection;

   nsresult result = GetSelection(getter_AddRefs(selection));

   // if we don't get the selection, just skip this

   if (NS_SUCCEEDED(result) && selection) 

   {

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

     nsCOMPtr<nsISelectionListener>listener;

     listener = do_QueryInterface(mTypeInState);

     if (listener)

     {

       selPriv->RemoveSelectionListener(listener); 

     }

     listener = do_QueryInterface(mSelectionListenerP);

     if (listener)

     {

       selPriv->RemoveSelectionListener(listener); 

     }

   }

   mTypeInState = nullptr;

   mSelectionListenerP = nullptr;

   // free any default style propItems

   RemoveAllDefaultProperties();

   if (mLinkHandler && mDocWeak)

   {

     nsCOMPtr<nsIPresShell> ps = GetPresShell();

     if (ps && ps->GetPresContext())

     {

       ps->GetPresContext()->SetLinkHandler(mLinkHandler);

     }

   }

   RemoveEventListeners();

 }

 void

 nsHTMLEditor::HideAnonymousEditingUIs()

 {

   if (mAbsolutelyPositionedObject)

     HideGrabber();

   if (mInlineEditedCell)

     HideInlineTableEditingUI();

   if (mResizedObject)

     HideResizers();

 }

 NS_IMPL_CYCLE_COLLECTION_CLASS(nsHTMLEditor)

 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsHTMLEditor, nsPlaintextEditor)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTypeInState)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mStyleSheets)

   tmp->HideAnonymousEditingUIs();

 NS_IMPL_CYCLE_COLLECTION_UNLINK_END

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsHTMLEditor, nsPlaintextEditor)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTypeInState)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheets)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopLeftHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopRightHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLeftHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRightHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBottomLeftHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBottomHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBottomRightHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mActivatedHandle)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizingShadow)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizingInfo)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizedObject)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMouseMotionListenerP)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelectionListenerP)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizeEventListenerP)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(objectResizeEventListeners)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAbsolutelyPositionedObject)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGrabber)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPositioningShadow)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInlineEditedCell)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddColumnBeforeButton)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRemoveColumnButton)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddColumnAfterButton)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddRowBeforeButton)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRemoveRowButton)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddRowAfterButton)

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

 NS_IMPL_ADDREF_INHERITED(nsHTMLEditor, nsEditor)

 NS_IMPL_RELEASE_INHERITED(nsHTMLEditor, nsEditor)

 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsHTMLEditor)

   NS_INTERFACE_MAP_ENTRY(nsIHTMLEditor)

   NS_INTERFACE_MAP_ENTRY(nsIHTMLObjectResizer)

   NS_INTERFACE_MAP_ENTRY(nsIHTMLAbsPosEditor)

   NS_INTERFACE_MAP_ENTRY(nsIHTMLInlineTableEditor)

   NS_INTERFACE_MAP_ENTRY(nsITableEditor)

   NS_INTERFACE_MAP_ENTRY(nsIEditorStyleSheets)

   NS_INTERFACE_MAP_ENTRY(nsICSSLoaderObserver)

   NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)

 NS_INTERFACE_MAP_END_INHERITING(nsPlaintextEditor)

 NS_IMETHODIMP

 nsHTMLEditor::Init(nsIDOMDocument *aDoc,

                    nsIContent *aRoot,

                    nsISelectionController *aSelCon,

                    uint32_t aFlags,

                    const nsAString& aInitialValue)

 {

   NS_PRECONDITION(aDoc && !aSelCon, "bad arg");

   NS_ENSURE_TRUE(aDoc, NS_ERROR_NULL_POINTER);

   MOZ_ASSERT(aInitialValue.IsEmpty(), "Non-empty initial values not supported");

   nsresult result = NS_OK, rulesRes = NS_OK;

   if (1)

   {

     // block to scope nsAutoEditInitRulesTrigger

     nsAutoEditInitRulesTrigger rulesTrigger(static_cast<nsPlaintextEditor*>(this), rulesRes);

     // Init the plaintext editor

     result = nsPlaintextEditor::Init(aDoc, aRoot, nullptr, aFlags, aInitialValue);

     if (NS_FAILED(result)) { return result; }

     // Init mutation observer

     nsCOMPtr<nsINode> document = do_QueryInterface(aDoc);

     document->AddMutationObserverUnlessExists(this);

     // disable Composer-only features

     if (IsMailEditor())

     {

       SetAbsolutePositioningEnabled(false);

       SetSnapToGridEnabled(false);

     }

     // Init the HTML-CSS utils

     mHTMLCSSUtils = new nsHTMLCSSUtils(this);

     // disable links

     nsCOMPtr<nsIPresShell> presShell = GetPresShell();

     NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);

     nsPresContext *context = presShell->GetPresContext();

     NS_ENSURE_TRUE(context, NS_ERROR_NULL_POINTER);

     if (!IsPlaintextEditor() && !IsInteractionAllowed()) {

       mLinkHandler = context->GetLinkHandler();

       context->SetLinkHandler(nullptr);

     }

     // init the type-in state

     mTypeInState = new TypeInState();

     // init the selection listener for image resizing

     mSelectionListenerP = new ResizerSelectionListener(this);

     if (!IsInteractionAllowed()) {

       // ignore any errors from this in case the file is missing

       AddOverrideStyleSheet(NS_LITERAL_STRING("resource://gre/res/EditorOverride.css"));

     }

     nsCOMPtr<nsISelection>selection;

     result = GetSelection(getter_AddRefs(selection));

     if (NS_FAILED(result)) { return result; }

     if (selection) 

     {

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

       nsCOMPtr<nsISelectionListener>listener;

       listener = do_QueryInterface(mTypeInState);

       if (listener) {

         selPriv->AddSelectionListener(listener); 

       }

       listener = do_QueryInterface(mSelectionListenerP);

       if (listener) {

         selPriv->AddSelectionListener(listener); 

       }

     }

   }

   NS_ENSURE_SUCCESS(rulesRes, rulesRes);

   return result;

 }

 NS_IMETHODIMP

 nsHTMLEditor::PreDestroy(bool aDestroyingFrames)

 {

   if (mDidPreDestroy) {

     return NS_OK;

   }

   nsCOMPtr<nsINode> document = do_QueryReferent(mDocWeak);

   if (document) {

     document->RemoveMutationObserver(this);

   }

   while (mStyleSheetURLs.Length())

   {

     RemoveOverrideStyleSheet(mStyleSheetURLs[0]);

   }

   // Clean up after our anonymous content -- we don't want these nodes to

   // stay around (which they would, since the frames have an owning reference).

   HideAnonymousEditingUIs();

   return nsPlaintextEditor::PreDestroy(aDestroyingFrames);

 }

 NS_IMETHODIMP

 nsHTMLEditor::GetRootElement(nsIDOMElement **aRootElement)

 {

   NS_ENSURE_ARG_POINTER(aRootElement);

   if (mRootElement) {

     return nsEditor::GetRootElement(aRootElement);

   }

   *aRootElement = nullptr;

   // Use the HTML documents body element as the editor root if we didn't

   // get a root element during initialization.

   nsCOMPtr<nsIDOMElement> rootElement; 

   nsCOMPtr<nsIDOMHTMLElement> bodyElement; 

   nsresult rv = GetBodyElement(getter_AddRefs(bodyElement));

   NS_ENSURE_SUCCESS(rv, rv);

   if (bodyElement) {

     rootElement = bodyElement;

   } else {

     // If there is no HTML body element,

     // we should use the document root element instead.

     nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);

     NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);

     rv = doc->GetDocumentElement(getter_AddRefs(rootElement));

     NS_ENSURE_SUCCESS(rv, rv);

     // Document can have no elements

     if (!rootElement) {

       return NS_ERROR_NOT_AVAILABLE;

     }

   }

   mRootElement = do_QueryInterface(rootElement);

   rootElement.forget(aRootElement);

   return NS_OK;

 }

 already_AddRefed<nsIContent>

 nsHTMLEditor::FindSelectionRoot(nsINode *aNode)

 {

   NS_PRECONDITION(aNode->IsNodeOfType(nsINode::eDOCUMENT) ||

                   aNode->IsNodeOfType(nsINode::eCONTENT),

                   "aNode must be content or document node");

   nsCOMPtr<nsIDocument> doc = aNode->GetCurrentDoc();

   if (!doc) {

     return nullptr;

   }

   nsCOMPtr<nsIContent> content;

   if (doc->HasFlag(NODE_IS_EDITABLE) || !aNode->IsContent()) {

     content = doc->GetRootElement();

     return content.forget();

   }

   content = aNode->AsContent();

   // XXX If we have readonly flag, shouldn't return the element which has

   // contenteditable="true"?  However, such case isn't there without chrome

   // permission script.

   if (IsReadonly()) {

     // We still want to allow selection in a readonly editor.

     content = do_QueryInterface(GetRoot());

     return content.forget();

   }

   if (!content->HasFlag(NODE_IS_EDITABLE)) {

     // If the content is in read-write state but is not editable itself,

     // return it as the selection root.

     if (content->IsElement() &&

         content->AsElement()->State().HasState(NS_EVENT_STATE_MOZ_READWRITE)) {

       return content.forget();

     }

     return nullptr;

   }

   // For non-readonly editors we want to find the root of the editable subtree

   // containing aContent.

   content = content->GetEditingHost();

   return content.forget();

 }

 /* virtual */

 void

 nsHTMLEditor::CreateEventListeners()

 {

   // Don't create the handler twice

   if (!mEventListener) {

     mEventListener = new nsHTMLEditorEventListener();

   }

 }

 nsresult

 nsHTMLEditor::InstallEventListeners()

 {

   NS_ENSURE_TRUE(mDocWeak && mEventListener,

                  NS_ERROR_NOT_INITIALIZED);

   // NOTE: nsHTMLEditor doesn't need to initialize mEventTarget here because

   // the target must be document node and it must be referenced as weak pointer.

   nsHTMLEditorEventListener* listener =

     reinterpret_cast<nsHTMLEditorEventListener*>(mEventListener.get());

   return listener->Connect(this);

 }

 void

 nsHTMLEditor::RemoveEventListeners()

 {

   if (!mDocWeak)

   {

     return;

   }

   nsCOMPtr<nsIDOMEventTarget> target = GetDOMEventTarget();

   if (target)

   {

     // Both mMouseMotionListenerP and mResizeEventListenerP can be

     // registerd with other targets than the DOM event receiver that

     // we can reach from here. But nonetheless, unregister the event

     // listeners with the DOM event reveiver (if it's registerd with

     // other targets, it'll get unregisterd once the target goes

     // away).

     if (mMouseMotionListenerP)

     {

       // mMouseMotionListenerP might be registerd either as bubbling or

       // capturing, unregister by both.

       target->RemoveEventListener(NS_LITERAL_STRING("mousemove"),

                                   mMouseMotionListenerP, false);

       target->RemoveEventListener(NS_LITERAL_STRING("mousemove"),

                                   mMouseMotionListenerP, true);

     }

     if (mResizeEventListenerP)

     {

       target->RemoveEventListener(NS_LITERAL_STRING("resize"),

                                   mResizeEventListenerP, false);

     }

   }

   mMouseMotionListenerP = nullptr;

   mResizeEventListenerP = nullptr;

   nsPlaintextEditor::RemoveEventListeners();

 }

 NS_IMETHODIMP 

 nsHTMLEditor::SetFlags(uint32_t aFlags)

 {

   nsresult rv = nsPlaintextEditor::SetFlags(aFlags);

   NS_ENSURE_SUCCESS(rv, rv);

   // Sets mCSSAware to correspond to aFlags. This toggles whether CSS is

   // used to style elements in the editor. Note that the editor is only CSS

   // aware by default in Composer and in the mail editor.

   mCSSAware = !NoCSS() && !IsMailEditor();

   return NS_OK;

 }

 NS_IMETHODIMP

 nsHTMLEditor::InitRules()

 {

   if (!mRules) {

     // instantiate the rules for the html editor

     mRules = new nsHTMLEditRules();

   }

   return mRules->Init(static_cast<nsPlaintextEditor*>(this));

 }

 NS_IMETHODIMP

 nsHTMLEditor::BeginningOfDocument()

 {

   if (!mDocWeak) { return NS_ERROR_NOT_INITIALIZED; }

   // get the selection

   nsCOMPtr<nsISelection> selection;

   nsresult res = GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);

   // Get the root element.

   nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(GetRoot());

   if (!rootElement) {

     NS_WARNING("GetRoot() returned a null pointer (mRootElement is null)");

     return NS_OK;

   }

   // find first editable thingy

   bool done = false;

   nsCOMPtr<nsIDOMNode> curNode(rootElement), selNode;

   int32_t curOffset = 0, selOffset;

   while (!done)

   {

     nsWSRunObject wsObj(this, curNode, curOffset);

     nsCOMPtr<nsIDOMNode> visNode;

     int32_t visOffset=0;

     WSType visType;

     wsObj.NextVisibleNode(curNode, curOffset, address_of(visNode), &visOffset, &visType);

     if (visType == WSType::normalWS || visType == WSType::text) {

       selNode = visNode;

       selOffset = visOffset;

       done = true;

     } else if (visType == WSType::br || visType == WSType::special) {

       selNode = GetNodeLocation(visNode, &selOffset);

       done = true;

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

       // By definition of nsWSRunObject, a block element terminates 

       // a whitespace run. That is, although we are calling a method 

       // that is named "NextVisibleNode", the node returned

       // might not be visible/editable!

       // If the given block does not contain any visible/editable items,

       // we want to skip it and continue our search.

       if (!IsContainer(visNode))

       {

         // However, we were given a block that is not a container.

         // Since the block can not contain anything that's visible,

         // such a block only makes sense if it is visible by itself,

         // like a <hr>

         // We want to place the caret in front of that block.

         selNode = GetNodeLocation(visNode, &selOffset);

         done = true;

       }

       else

       {

         bool isEmptyBlock;

         if (NS_SUCCEEDED(IsEmptyNode(visNode, &isEmptyBlock)) &&

             isEmptyBlock)

         {

           // skip the empty block

           curNode = GetNodeLocation(visNode, &curOffset);

           ++curOffset;

         }

         else

         {

           curNode = visNode;

           curOffset = 0;

         }

         // keep looping

       }

     }

     else

     {

       // else we found nothing useful

       selNode = curNode;

       selOffset = curOffset;

       done = true;

     }

   }

   return selection->Collapse(selNode, selOffset);

 }

 nsresult

 nsHTMLEditor::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent)

 {

   // NOTE: When you change this method, you should also change:

   //   * editor/libeditor/html/tests/test_htmleditor_keyevent_handling.html

   if (IsReadonly() || IsDisabled()) {

     // When we're not editable, the events are handled on nsEditor, so, we can

     // bypass nsPlaintextEditor.

     return nsEditor::HandleKeyPressEvent(aKeyEvent);

   }

   WidgetKeyboardEvent* nativeKeyEvent =

     aKeyEvent->GetInternalNSEvent()->AsKeyboardEvent();

   NS_ENSURE_TRUE(nativeKeyEvent, NS_ERROR_UNEXPECTED);

   NS_ASSERTION(nativeKeyEvent->message == NS_KEY_PRESS,

                "HandleKeyPressEvent gets non-keypress event");

   switch (nativeKeyEvent->keyCode) {

     case nsIDOMKeyEvent::DOM_VK_META:

     case nsIDOMKeyEvent::DOM_VK_WIN:

     case nsIDOMKeyEvent::DOM_VK_SHIFT:

     case nsIDOMKeyEvent::DOM_VK_CONTROL:

     case nsIDOMKeyEvent::DOM_VK_ALT:

     case nsIDOMKeyEvent::DOM_VK_BACK_SPACE:

     case nsIDOMKeyEvent::DOM_VK_DELETE:

       // These keys are handled on nsEditor, so, we can bypass

       // nsPlaintextEditor.

       return nsEditor::HandleKeyPressEvent(aKeyEvent);

     case nsIDOMKeyEvent::DOM_VK_TAB: {

       if (IsPlaintextEditor()) {

         // If this works as plain text editor, e.g., mail editor for plain

         // text, should be handled on nsPlaintextEditor.

         return nsPlaintextEditor::HandleKeyPressEvent(aKeyEvent);

       }

       if (IsTabbable()) {

         return NS_OK; // let it be used for focus switching

       }

       if (nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() ||

           nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) {

         return NS_OK;

       }

       nsCOMPtr<nsISelection> selection;

       nsresult rv = GetSelection(getter_AddRefs(selection));

       NS_ENSURE_SUCCESS(rv, rv);

       int32_t offset;

       nsCOMPtr<nsIDOMNode> node, blockParent;

       rv = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);

       NS_ENSURE_SUCCESS(rv, rv);

       NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);

       bool isBlock = false;

       NodeIsBlock(node, &isBlock);

       if (isBlock) {

         blockParent = node;

       } else {

         blockParent = GetBlockNodeParent(node);

       }

       if (!blockParent) {

         break;

       }

       bool handled = false;

       if (nsHTMLEditUtils::IsTableElement(blockParent)) {

         rv = TabInTable(nativeKeyEvent->IsShift(), &handled);

         if (handled) {

           ScrollSelectionIntoView(false);

         }

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

         rv = Indent(nativeKeyEvent->IsShift() ?

                       NS_LITERAL_STRING("outdent") :

                       NS_LITERAL_STRING("indent"));

         handled = true;

       }

       NS_ENSURE_SUCCESS(rv, rv);

       if (handled) {

         return aKeyEvent->PreventDefault(); // consumed

       }

       if (nativeKeyEvent->IsShift()) {

         return NS_OK; // don't type text for shift tabs

       }

       aKeyEvent->PreventDefault();

       return TypedText(NS_LITERAL_STRING("\t"), eTypedText);

     }

     case nsIDOMKeyEvent::DOM_VK_RETURN:

       if (nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() ||

           nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) {

         return NS_OK;

       }

       aKeyEvent->PreventDefault(); // consumed

       if (nativeKeyEvent->IsShift() && !IsPlaintextEditor()) {

         // only inserts a br node

         return TypedText(EmptyString(), eTypedBR);

       }

       // uses rules to figure out what to insert

       return TypedText(EmptyString(), eTypedBreak);

   }

   // NOTE: On some keyboard layout, some characters are inputted with Control

   // key or Alt key, but at that time, widget sets FALSE to these keys.

   if (nativeKeyEvent->charCode == 0 || nativeKeyEvent->IsControl() ||

       nativeKeyEvent->IsAlt() || nativeKeyEvent->IsMeta() ||

       nativeKeyEvent->IsOS()) {

     // we don't PreventDefault() here or keybindings like control-x won't work

     return NS_OK;

   }

   aKeyEvent->PreventDefault();

   nsAutoString str(nativeKeyEvent->charCode);

   return TypedText(str, eTypedText);

 }

 static void

 AssertParserServiceIsCorrect(nsIAtom* aTag, bool aIsBlock)

 {

 #ifdef DEBUG

   // Check this against what we would have said with the old code:

   if (aTag==nsEditProperty::p          ||

       aTag==nsEditProperty::div        ||

       aTag==nsEditProperty::blockquote ||

       aTag==nsEditProperty::h1         ||

       aTag==nsEditProperty::h2         ||

       aTag==nsEditProperty::h3         ||

       aTag==nsEditProperty::h4         ||

       aTag==nsEditProperty::h5         ||

       aTag==nsEditProperty::h6         ||

       aTag==nsEditProperty::ul         ||

       aTag==nsEditProperty::ol         ||

       aTag==nsEditProperty::dl         ||

       aTag==nsEditProperty::noscript   ||

       aTag==nsEditProperty::form       ||

       aTag==nsEditProperty::hr         ||

       aTag==nsEditProperty::table      ||

       aTag==nsEditProperty::fieldset   ||

       aTag==nsEditProperty::address    ||

       aTag==nsEditProperty::col        ||

       aTag==nsEditProperty::colgroup   ||

       aTag==nsEditProperty::li         ||

       aTag==nsEditProperty::dt         ||

       aTag==nsEditProperty::dd         ||

       aTag==nsEditProperty::legend     )

   {

     if (!aIsBlock) {

       nsAutoString assertmsg (NS_LITERAL_STRING("Parser and editor disagree on blockness: "));

       nsAutoString tagName;

       aTag->ToString(tagName);

       assertmsg.Append(tagName);

       char* assertstr = ToNewCString(assertmsg);

       NS_ASSERTION(aIsBlock, assertstr);

       NS_Free(assertstr);

     }

   }

 #endif // DEBUG

 }

 /**

  * Returns true if the id represents an element of block type.

  * Can be used to determine if a new paragraph should be started.

  */

 bool

 nsHTMLEditor::NodeIsBlockStatic(const dom::Element* aElement)

 {

   MOZ_ASSERT(aElement);

   nsIAtom* tagAtom = aElement->Tag();

   MOZ_ASSERT(tagAtom);

   // Nodes we know we want to treat as block

   // even though the parser says they're not:

   if (tagAtom==nsEditProperty::body       ||

       tagAtom==nsEditProperty::head       ||

       tagAtom==nsEditProperty::tbody      ||

       tagAtom==nsEditProperty::thead      ||

       tagAtom==nsEditProperty::tfoot      ||

       tagAtom==nsEditProperty::tr         ||

       tagAtom==nsEditProperty::th         ||

       tagAtom==nsEditProperty::td         ||

       tagAtom==nsEditProperty::li         ||

       tagAtom==nsEditProperty::dt         ||

       tagAtom==nsEditProperty::dd         ||

       tagAtom==nsEditProperty::pre)

   {

     return true;

   }

   bool isBlock;

 #ifdef DEBUG

   // XXX we can't use DebugOnly here because VC++ is stupid (bug 802884)

   nsresult rv =

 #endif

     nsContentUtils::GetParserService()->

     IsBlock(nsContentUtils::GetParserService()->HTMLAtomTagToId(tagAtom),

             isBlock);

   MOZ_ASSERT(rv == NS_OK);

   AssertParserServiceIsCorrect(tagAtom, isBlock);

   return isBlock;

 }

 nsresult

 nsHTMLEditor::NodeIsBlockStatic(nsIDOMNode *aNode, bool *aIsBlock)

 {

   if (!aNode || !aIsBlock) { return NS_ERROR_NULL_POINTER; }

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

   *aIsBlock = element && NodeIsBlockStatic(element);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsHTMLEditor::NodeIsBlock(nsIDOMNode *aNode, bool *aIsBlock)

 {

   return NodeIsBlockStatic(aNode, aIsBlock);

 }

 bool

 nsHTMLEditor::IsBlockNode(nsINode *aNode)

 {

   return aNode && aNode->IsElement() && NodeIsBlockStatic(aNode->AsElement());

 }

 // Non-static version for the nsIEditor interface and JavaScript

 NS_IMETHODIMP 

 nsHTMLEditor::SetDocumentTitle(const nsAString &aTitle)

 {

   nsRefPtr<SetDocTitleTxn> txn = new SetDocTitleTxn();

   NS_ENSURE_TRUE(txn, NS_ERROR_OUT_OF_MEMORY);

   nsresult result = txn->Init(this, &aTitle);

   NS_ENSURE_SUCCESS(result, result);

   //Don't let Rules System change the selection

   nsAutoTxnsConserveSelection dontChangeSelection(this);

   return nsEditor::DoTransaction(txn);  

 }

 /* ------------ Block methods moved from nsEditor -------------- */

 ///////////////////////////////////////////////////////////////////////////

 // GetBlockNodeParent: returns enclosing block level ancestor, if any

 //

 already_AddRefed<nsIDOMNode>

 nsHTMLEditor::GetBlockNodeParent(nsIDOMNode *aNode)

 {

   if (!aNode)

   {

     NS_NOTREACHED("null node passed to GetBlockNodeParent()");

     return nullptr;

   }

   nsCOMPtr<nsIDOMNode> p;

   if (NS_FAILED(aNode->GetParentNode(getter_AddRefs(p))))  // no parent, ran off top of tree

     return nullptr;

   nsCOMPtr<nsIDOMNode> tmp;

   while (p)

   {

     bool isBlock;

     if (NS_FAILED(NodeIsBlockStatic(p, &isBlock)) || isBlock)

       break;

     if (NS_FAILED(p->GetParentNode(getter_AddRefs(tmp))) || !tmp) // no parent, ran off top of tree

       break;

     p = tmp;

   }

   return p.forget();

 }

 static const char16_t nbsp = 160;

 ///////////////////////////////////////////////////////////////////////////////

 // IsNextCharInNodeWhitespace: checks the adjacent content in the same node to

 //                             see if following selection is whitespace or nbsp

 void

 nsHTMLEditor::IsNextCharInNodeWhitespace(nsIContent* aContent,

                                          int32_t aOffset,

                                          bool* outIsSpace,

                                          bool* outIsNBSP,

                                          nsIContent** outNode,

                                          int32_t* outOffset)

 {

   MOZ_ASSERT(aContent && outIsSpace && outIsNBSP);

   MOZ_ASSERT((outNode && outOffset) || (!outNode && !outOffset));

   *outIsSpace = false;

   *outIsNBSP = false;

   if (outNode && outOffset) {

     *outNode = nullptr;

     *outOffset = -1;

   }

   if (aContent->IsNodeOfType(nsINode::eTEXT) &&

       (uint32_t)aOffset < aContent->Length()) {

     char16_t ch = aContent->GetText()->CharAt(aOffset);

     *outIsSpace = nsCRT::IsAsciiSpace(ch);

     *outIsNBSP = (ch == nbsp);

     if (outNode && outOffset) {

       NS_IF_ADDREF(*outNode = aContent);

       // yes, this is _past_ the character

       *outOffset = aOffset + 1;

     }

   }

 }

 ///////////////////////////////////////////////////////////////////////////////

 // IsPrevCharInNodeWhitespace: checks the adjacent content in the same node to

 //                             see if following selection is whitespace

 void

 nsHTMLEditor::IsPrevCharInNodeWhitespace(nsIContent* aContent,

                                          int32_t aOffset,

                                          bool* outIsSpace,

                                          bool* outIsNBSP,

                                          nsIContent** outNode,

                                          int32_t* outOffset)

 {

   MOZ_ASSERT(aContent && outIsSpace && outIsNBSP);

   MOZ_ASSERT((outNode && outOffset) || (!outNode && !outOffset));

   *outIsSpace = false;

   *outIsNBSP = false;

   if (outNode && outOffset) {

     *outNode = nullptr;

     *outOffset = -1;

   }

   if (aContent->IsNodeOfType(nsINode::eTEXT) && aOffset > 0) {

     char16_t ch = aContent->GetText()->CharAt(aOffset - 1);

     *outIsSpace = nsCRT::IsAsciiSpace(ch);

     *outIsNBSP = (ch == nbsp);

     if (outNode && outOffset) {

       NS_IF_ADDREF(*outNode = aContent);

       *outOffset = aOffset - 1;

     }

   }

 }

 /* ------------ End Block methods -------------- */

 bool nsHTMLEditor::IsVisBreak(nsIDOMNode *aNode)

 {

   NS_ENSURE_TRUE(aNode, false);

   if (!nsTextEditUtils::IsBreak(aNode)) 

     return false;

   // check if there is a later node in block after br

   nsCOMPtr<nsIDOMNode> priorNode, nextNode;

   GetPriorHTMLNode(aNode, address_of(priorNode), true); 

   GetNextHTMLNode(aNode, address_of(nextNode), true); 

   // if we are next to another break, we are visible

   if (priorNode && nsTextEditUtils::IsBreak(priorNode))

     return true;

   if (nextNode && nsTextEditUtils::IsBreak(nextNode))

     return true;

   // if we are right before block boundary, then br not visible

   NS_ENSURE_TRUE(nextNode, false);  // this break is trailer in block, it's not visible

   if (IsBlockNode(nextNode))

     return false; // break is right before a block, it's not visible

   // sigh.  We have to use expensive whitespace calculation code to 

   // determine what is going on

   nsCOMPtr<nsIDOMNode> selNode, tmp;

   int32_t selOffset;

   selNode = GetNodeLocation(aNode, &selOffset);

   selOffset++; // lets look after the break

   nsWSRunObject wsObj(this, selNode, selOffset);

   nsCOMPtr<nsIDOMNode> visNode;

   int32_t visOffset=0;

   WSType visType;

   wsObj.NextVisibleNode(selNode, selOffset, address_of(visNode), &visOffset, &visType);

   if (visType & WSType::block) {

     return false;

   }

   return true;

 }

 NS_IMETHODIMP

 nsHTMLEditor::BreakIsVisible(nsIDOMNode *aNode, bool *aIsVisible)

 {

   NS_ENSURE_ARG_POINTER(aNode && aIsVisible);

   *aIsVisible = IsVisBreak(aNode);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsHTMLEditor::GetIsDocumentEditable(bool *aIsDocumentEditable)

 {

   NS_ENSURE_ARG_POINTER(aIsDocumentEditable);

   nsCOMPtr<nsIDOMDocument> doc = GetDOMDocument();

   *aIsDocumentEditable = doc && IsModifiable();

   return NS_OK;

 }

 bool nsHTMLEditor::IsModifiable()

 {

   return !IsReadonly();

 }

 NS_IMETHODIMP

 nsHTMLEditor::UpdateBaseURL()

 {

   nsCOMPtr<nsIDOMDocument> domDoc = GetDOMDocument();

   NS_ENSURE_TRUE(domDoc, NS_ERROR_FAILURE);

   // Look for an HTML <base> tag

   nsCOMPtr<nsIDOMNodeList> nodeList;

   nsresult rv = domDoc->GetElementsByTagName(NS_LITERAL_STRING("base"), getter_AddRefs(nodeList));

   NS_ENSURE_SUCCESS(rv, rv);

   nsCOMPtr<nsIDOMNode> baseNode;

   if (nodeList)

   {

     uint32_t count;

     nodeList->GetLength(&count);

     if (count >= 1)

     {

       rv = nodeList->Item(0, getter_AddRefs(baseNode));

       NS_ENSURE_SUCCESS(rv, rv);

     }

   }

   // If no base tag, then set baseURL to the document's URL

   // This is very important, else relative URLs for links and images are wrong

   if (!baseNode)

   {

     nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);

     NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);

     return doc->SetBaseURI(doc->GetDocumentURI());

   }

   return NS_OK;

 }

 /* This routine is needed to provide a bottleneck for typing for logging

    purposes.  Can't use HandleKeyPress() (above) for that since it takes

    a nsIDOMKeyEvent* parameter.  So instead we pass enough info through

    to TypedText() to determine what action to take, but without passing

    an event.

    */

 NS_IMETHODIMP

 nsHTMLEditor::TypedText(const nsAString& aString, ETypingAction aAction)

 {

   nsAutoPlaceHolderBatch batch(this, nsGkAtoms::TypingTxnName);

   if (aAction == eTypedBR) {

     // only inserts a br node

     nsCOMPtr<nsIDOMNode> brNode;

     return InsertBR(address_of(brNode));

   }

   return nsPlaintextEditor::TypedText(aString, aAction);

 }

 NS_IMETHODIMP nsHTMLEditor::TabInTable(bool inIsShift, bool *outHandled)

 {

   NS_ENSURE_TRUE(outHandled, NS_ERROR_NULL_POINTER);

   *outHandled = false;

   // Find enclosing table cell from the selection (cell may be the selected element)

   nsCOMPtr<nsIDOMElement> cellElement;

     // can't use |NS_LITERAL_STRING| here until |GetElementOrParentByTagName| is fixed to accept readables

   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr, getter_AddRefs(cellElement));

   NS_ENSURE_SUCCESS(res, res);

   // Do nothing -- we didn't find a table cell

   NS_ENSURE_TRUE(cellElement, NS_OK);

   // find enclosing table

   nsCOMPtr<nsIDOMNode> tbl = GetEnclosingTable(cellElement);

   NS_ENSURE_TRUE(tbl, res);

   // advance to next cell

   // first create an iterator over the table

   nsCOMPtr<nsIContentIterator> iter =

       do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &res);

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(iter, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsIContent> cTbl = do_QueryInterface(tbl);

   nsCOMPtr<nsIContent> cBlock = do_QueryInterface(cellElement);

   res = iter->Init(cTbl);

   NS_ENSURE_SUCCESS(res, res);

   // position iter at block

   res = iter->PositionAt(cBlock);

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMNode> node;

   do

   {

     if (inIsShift)

       iter->Prev();

     else

       iter->Next();

     node = do_QueryInterface(iter->GetCurrentNode());

     if (node && nsHTMLEditUtils::IsTableCell(node) &&

         GetEnclosingTable(node) == tbl)

     {

       res = CollapseSelectionToDeepestNonTableFirstChild(nullptr, node);

       NS_ENSURE_SUCCESS(res, res);

       *outHandled = true;

       return NS_OK;

     }

   } while (!iter->IsDone());

   if (!(*outHandled) && !inIsShift)

   {

     // if we havent handled it yet then we must have run off the end of

     // the table.  Insert a new row.

     res = InsertTableRow(1, true);

     NS_ENSURE_SUCCESS(res, res);

     *outHandled = true;

     // put selection in right place

     // Use table code to get selection and index to new row...

     nsCOMPtr<nsISelection>selection;

     nsCOMPtr<nsIDOMElement> tblElement;

     nsCOMPtr<nsIDOMElement> cell;

     int32_t row;

     res = GetCellContext(getter_AddRefs(selection), 

                          getter_AddRefs(tblElement),

                          getter_AddRefs(cell), 

                          nullptr, nullptr,

                          &row, nullptr);

     NS_ENSURE_SUCCESS(res, res);

     // ...so that we can ask for first cell in that row...

     res = GetCellAt(tblElement, row, 0, getter_AddRefs(cell));

     NS_ENSURE_SUCCESS(res, res);

     // ...and then set selection there.

     // (Note that normally you should use CollapseSelectionToDeepestNonTableFirstChild(),

     //  but we know cell is an empty new cell, so this works fine)

     node = do_QueryInterface(cell);

     if (node) selection->Collapse(node,0);

     return NS_OK;

   }

   return res;

 }

 NS_IMETHODIMP nsHTMLEditor::CreateBR(nsIDOMNode *aNode, int32_t aOffset, nsCOMPtr<nsIDOMNode> *outBRNode, EDirection aSelect)

 {

   nsCOMPtr<nsIDOMNode> parent = aNode;

   int32_t offset = aOffset;

   return CreateBRImpl(address_of(parent), &offset, outBRNode, aSelect);

 }

 nsresult 

 nsHTMLEditor::CollapseSelectionToDeepestNonTableFirstChild(nsISelection *aSelection, nsIDOMNode *aNode)

 {

   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);

   nsresult res;

   nsCOMPtr<nsISelection> selection;

   if (aSelection)

   {

     selection = aSelection;

   } else {

     res = GetSelection(getter_AddRefs(selection));

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);

   }

   nsCOMPtr<nsIDOMNode> node = aNode;

   nsCOMPtr<nsIDOMNode> child;

   do {

     node->GetFirstChild(getter_AddRefs(child));

     if (child)

     {

       // Stop if we find a table

       // don't want to go into nested tables

       if (nsHTMLEditUtils::IsTable(child)) break;

       // hey, it'g gotta be a container too!

       if (!IsContainer(child)) break;

       node = child;

     }

   }

   while (child);

   selection->Collapse(node,0);

   return NS_OK;

 }

 // This is mostly like InsertHTMLWithCharsetAndContext, 

 //  but we can't use that because it is selection-based and 

 //  the rules code won't let us edit under the <head> node

 NS_IMETHODIMP

 nsHTMLEditor::ReplaceHeadContentsWithHTML(const nsAString& aSourceToInsert)

 {

   nsAutoRules beginRulesSniffing(this, EditAction::ignore, nsIEditor::eNone); // don't do any post processing, rules get confused

   nsCOMPtr<nsISelection> selection;

   nsresult res = GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   ForceCompositionEnd();

   // Do not use nsAutoRules -- rules code won't let us insert in <head>

   // Use the head node as a parent and delete/insert directly

   nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);

   NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);

   nsCOMPtr<nsIDOMNodeList>nodeList; 

   res = doc->GetElementsByTagName(NS_LITERAL_STRING("head"), getter_AddRefs(nodeList));

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(nodeList, NS_ERROR_NULL_POINTER);

   uint32_t count; 

   nodeList->GetLength(&count);

   if (count < 1) return NS_ERROR_FAILURE;

   nsCOMPtr<nsIDOMNode> headNode;

   res = nodeList->Item(0, getter_AddRefs(headNode)); 

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(headNode, NS_ERROR_NULL_POINTER);

   // First, make sure there are no return chars in the source.

   // Bad things happen if you insert returns (instead of dom newlines, \n)

   // into an editor document.

   nsAutoString inputString (aSourceToInsert);  // hope this does copy-on-write

   // Windows linebreaks: Map CRLF to LF:

   inputString.ReplaceSubstring(MOZ_UTF16("\r\n"),

                                MOZ_UTF16("\n"));

   // Mac linebreaks: Map any remaining CR to LF:

   inputString.ReplaceSubstring(MOZ_UTF16("\r"),

                                MOZ_UTF16("\n"));

   nsAutoEditBatch beginBatching(this);

   res = GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   // Get the first range in the selection, for context:

   nsCOMPtr<nsIDOMRange> range;

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

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMDocumentFragment> docfrag;

   res = range->CreateContextualFragment(inputString,

                                         getter_AddRefs(docfrag));

   //XXXX BUG 50965: This is not returning the text between <title> ... </title>

   // Special code is needed in JS to handle title anyway, so it really doesn't matter!

   if (NS_FAILED(res))

   {

 #ifdef DEBUG

     printf("Couldn't create contextual fragment: error was %X\n",

            static_cast<uint32_t>(res));

 #endif

     return res;

   }

   NS_ENSURE_TRUE(docfrag, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsIDOMNode> child;

   // First delete all children in head

   do {

     res = headNode->GetFirstChild(getter_AddRefs(child));

     NS_ENSURE_SUCCESS(res, res);

     if (child)

     {

       res = DeleteNode(child);

       NS_ENSURE_SUCCESS(res, res);

     }

   } while (child);

   // Now insert the new nodes

   int32_t offsetOfNewNode = 0;

   nsCOMPtr<nsIDOMNode> fragmentAsNode (do_QueryInterface(docfrag));

   // Loop over the contents of the fragment and move into the document

   do {

     res = fragmentAsNode->GetFirstChild(getter_AddRefs(child));

     NS_ENSURE_SUCCESS(res, res);

     if (child)

     {

       res = InsertNode(child, headNode, offsetOfNewNode++);

       NS_ENSURE_SUCCESS(res, res);

     }

   } while (child);

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::RebuildDocumentFromSource(const nsAString& aSourceString)

 {

   ForceCompositionEnd();

   nsCOMPtr<nsISelection>selection;

   nsresult res = GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMElement> bodyElement = do_QueryInterface(GetRoot());

   NS_ENSURE_TRUE(bodyElement, NS_ERROR_NULL_POINTER);

   // Find where the <body> tag starts.

   nsReadingIterator<char16_t> beginbody;

   nsReadingIterator<char16_t> endbody;

   aSourceString.BeginReading(beginbody);

   aSourceString.EndReading(endbody);

   bool foundbody = CaseInsensitiveFindInReadable(NS_LITERAL_STRING("<body"),

                                                    beginbody, endbody);

   nsReadingIterator<char16_t> beginhead;

   nsReadingIterator<char16_t> endhead;

   aSourceString.BeginReading(beginhead);

   aSourceString.EndReading(endhead);

   bool foundhead = CaseInsensitiveFindInReadable(NS_LITERAL_STRING("<head"),

                                                    beginhead, endhead);

   // a valid head appears before the body

   if (foundbody && beginhead.get() > beginbody.get())

     foundhead = false;

   nsReadingIterator<char16_t> beginclosehead;

   nsReadingIterator<char16_t> endclosehead;

   aSourceString.BeginReading(beginclosehead);

   aSourceString.EndReading(endclosehead);

   // Find the index after "<head>"

   bool foundclosehead = CaseInsensitiveFindInReadable(

            NS_LITERAL_STRING("</head>"), beginclosehead, endclosehead);

   // a valid close head appears after a found head

   if (foundhead && beginhead.get() > beginclosehead.get())

     foundclosehead = false;

   // a valid close head appears before a found body

   if (foundbody && beginclosehead.get() > beginbody.get())

     foundclosehead = false;

   // Time to change the document

   nsAutoEditBatch beginBatching(this);

   nsReadingIterator<char16_t> endtotal;

   aSourceString.EndReading(endtotal);

   if (foundhead) {

     if (foundclosehead)

       res = ReplaceHeadContentsWithHTML(Substring(beginhead, beginclosehead));

     else if (foundbody)

       res = ReplaceHeadContentsWithHTML(Substring(beginhead, beginbody));

     else

       // XXX Without recourse to some parser/content sink/docshell hackery

       // we don't really know where the head ends and the body begins

       // so we assume that there is no body

       res = ReplaceHeadContentsWithHTML(Substring(beginhead, endtotal));

   } else {

     nsReadingIterator<char16_t> begintotal;

     aSourceString.BeginReading(begintotal);

     NS_NAMED_LITERAL_STRING(head, "<head>");

     if (foundclosehead)

       res = ReplaceHeadContentsWithHTML(head + Substring(begintotal, beginclosehead));

     else if (foundbody)

       res = ReplaceHeadContentsWithHTML(head + Substring(begintotal, beginbody));

     else

       // XXX Without recourse to some parser/content sink/docshell hackery

       // we don't really know where the head ends and the body begins

       // so we assume that there is no head

       res = ReplaceHeadContentsWithHTML(head);

   }

   NS_ENSURE_SUCCESS(res, res);

   res = SelectAll();

   NS_ENSURE_SUCCESS(res, res);

   if (!foundbody) {

     NS_NAMED_LITERAL_STRING(body, "<body>");

     // XXX Without recourse to some parser/content sink/docshell hackery

     // we don't really know where the head ends and the body begins

     if (foundclosehead) // assume body starts after the head ends

       res = LoadHTML(body + Substring(endclosehead, endtotal));

     else if (foundhead) // assume there is no body

       res = LoadHTML(body);

     else // assume there is no head, the entire source is body

       res = LoadHTML(body + aSourceString);

     NS_ENSURE_SUCCESS(res, res);

     nsCOMPtr<nsIDOMElement> divElement;

     res = CreateElementWithDefaults(NS_LITERAL_STRING("div"), getter_AddRefs(divElement));

     NS_ENSURE_SUCCESS(res, res);

     res = CloneAttributes(bodyElement, divElement);

     NS_ENSURE_SUCCESS(res, res);

     return BeginningOfDocument();

   }

   res = LoadHTML(Substring(beginbody, endtotal));

   NS_ENSURE_SUCCESS(res, res);

   // Now we must copy attributes user might have edited on the <body> tag

   //  because InsertHTML (actually, CreateContextualFragment()) 

   //  will never return a body node in the DOM fragment

   // We already know where "<body" begins

   nsReadingIterator<char16_t> beginclosebody = beginbody;

   nsReadingIterator<char16_t> endclosebody;

   aSourceString.EndReading(endclosebody);

   if (!FindInReadable(NS_LITERAL_STRING(">"),beginclosebody,endclosebody))

     return NS_ERROR_FAILURE;

   // Truncate at the end of the body tag

   // Kludge of the year: fool the parser by replacing "body" with "div" so we get a node

   nsAutoString bodyTag;

   bodyTag.AssignLiteral("<div ");

   bodyTag.Append(Substring(endbody, endclosebody));

   nsCOMPtr<nsIDOMRange> range;

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

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMDocumentFragment> docfrag;

   res = range->CreateContextualFragment(bodyTag, getter_AddRefs(docfrag));

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMNode> fragmentAsNode (do_QueryInterface(docfrag));

   NS_ENSURE_TRUE(fragmentAsNode, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsIDOMNode> child;

   res = fragmentAsNode->GetFirstChild(getter_AddRefs(child));

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(child, NS_ERROR_NULL_POINTER);

   // Copy all attributes from the div child to current body element

   res = CloneAttributes(bodyElement, child);

   NS_ENSURE_SUCCESS(res, res);

   // place selection at first editable content

   return BeginningOfDocument();

 }

 void

 nsHTMLEditor::NormalizeEOLInsertPosition(nsIDOMNode *firstNodeToInsert,

                                      nsCOMPtr<nsIDOMNode> *insertParentNode,

                                      int32_t *insertOffset)

 {

   /*

     This function will either correct the position passed in,

     or leave the position unchanged.

     When the (first) item to insert is a block level element, 

     and our insertion position is after the last visible item in a line, 

     i.e. the insertion position is just before a visible line break <br>, 

     we want to skip to the position just after the line break (see bug 68767)

     However, our logic to detect whether we should skip or not

     needs to be more clever.

     We must not skip when the caret appears to be positioned at the beginning

     of a block, in that case skipping the <br> would not insert the <br>

     at the caret position, but after the current empty line.

     So we have several cases to test:

     1) We only ever want to skip, if the next visible thing after the current position is a break

     2) We do not want to skip if there is no previous visible thing at all

        That is detected if the call to PriorVisibleNode gives us an offset of zero.

        Because PriorVisibleNode always positions after the prior node, we would

        see an offset > 0, if there were a prior node.

     3) We do not want to skip, if both the next and the previous visible things are breaks.

     4) We do not want to skip if the previous visible thing is in a different block

        than the insertion position.

   */

   if (!IsBlockNode(firstNodeToInsert))

     return;

   nsWSRunObject wsObj(this, *insertParentNode, *insertOffset);

   nsCOMPtr<nsIDOMNode> nextVisNode;

   nsCOMPtr<nsIDOMNode> prevVisNode;

   int32_t nextVisOffset=0;

   WSType nextVisType;

   int32_t prevVisOffset=0;

   WSType prevVisType;

   wsObj.NextVisibleNode(*insertParentNode, *insertOffset, address_of(nextVisNode), &nextVisOffset, &nextVisType);

   if (!nextVisNode)

     return;

   if (!(nextVisType & WSType::br)) {

     return;

   }

   wsObj.PriorVisibleNode(*insertParentNode, *insertOffset, address_of(prevVisNode), &prevVisOffset, &prevVisType);

   if (!prevVisNode)

     return;

   if (prevVisType & WSType::br) {

     return;

   }

   if (prevVisType & WSType::thisBlock) {

     return;

   }

   int32_t brOffset=0;

   nsCOMPtr<nsIDOMNode> brNode = GetNodeLocation(nextVisNode, &brOffset);

   *insertParentNode = brNode;

   *insertOffset = brOffset + 1;

 }

 NS_IMETHODIMP

 nsHTMLEditor::InsertElementAtSelection(nsIDOMElement* aElement, bool aDeleteSelection)

 {

   // Protect the edit rules object from dying

   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);

   nsresult res = NS_ERROR_NOT_INITIALIZED;

   NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aElement);

   ForceCompositionEnd();

   nsAutoEditBatch beginBatching(this);

   nsAutoRules beginRulesSniffing(this, EditAction::insertElement, nsIEditor::eNext);

   nsRefPtr<Selection> selection = GetSelection();

   if (!selection) {

     return NS_ERROR_FAILURE;

   }

   // hand off to the rules system, see if it has anything to say about this

   bool cancel, handled;

   nsTextRulesInfo ruleInfo(EditAction::insertElement);

   ruleInfo.insertElement = aElement;

   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);

   if (cancel || (NS_FAILED(res))) return res;

   if (!handled)

   {

     if (aDeleteSelection)

     {

       if (!IsBlockNode(aElement)) {

         // E.g., inserting an image.  In this case we don't need to delete any

         // inline wrappers before we do the insertion.  Otherwise we let

         // DeleteSelectionAndPrepareToCreateNode do the deletion for us, which

         // calls DeleteSelection with aStripWrappers = eStrip.

         res = DeleteSelection(nsIEditor::eNone, nsIEditor::eNoStrip);

         NS_ENSURE_SUCCESS(res, res);

       }

       nsresult result = DeleteSelectionAndPrepareToCreateNode();

       NS_ENSURE_SUCCESS(result, result);

     }

     // If deleting, selection will be collapsed.

     // so if not, we collapse it

     if (!aDeleteSelection)

     {

       // Named Anchor is a special case,

       // We collapse to insert element BEFORE the selection

       // For all other tags, we insert AFTER the selection

       if (nsHTMLEditUtils::IsNamedAnchor(node))

       {

         selection->CollapseToStart();

       } else {

         selection->CollapseToEnd();

       }

     }

     nsCOMPtr<nsIDOMNode> parentSelectedNode;

     int32_t offsetForInsert;

     res = selection->GetAnchorNode(getter_AddRefs(parentSelectedNode));

     // XXX: ERROR_HANDLING bad XPCOM usage

     if (NS_SUCCEEDED(res) && NS_SUCCEEDED(selection->GetAnchorOffset(&offsetForInsert)) && parentSelectedNode)

     {

 #ifdef DEBUG_cmanske

       {

       nsAutoString name;

       parentSelectedNode->GetNodeName(name);

       printf("InsertElement: Anchor node of selection: ");

       wprintf(name.get());

       printf(" Offset: %d\n", offsetForInsert);

       }

 #endif

       // Adjust position based on the node we are going to insert.

       NormalizeEOLInsertPosition(node, address_of(parentSelectedNode), &offsetForInsert);

       res = InsertNodeAtPoint(node, address_of(parentSelectedNode), &offsetForInsert, false);

       NS_ENSURE_SUCCESS(res, res);

       // Set caret after element, but check for special case 

       //  of inserting table-related elements: set in first cell instead

       if (!SetCaretInTableCell(aElement))

       {

         res = SetCaretAfterElement(aElement);

         NS_ENSURE_SUCCESS(res, res);

       }

       // check for inserting a whole table at the end of a block. If so insert a br after it.

       if (nsHTMLEditUtils::IsTable(node))

       {

         bool isLast;

         res = IsLastEditableChild(node, &isLast);

         NS_ENSURE_SUCCESS(res, res);

         if (isLast)

         {

           nsCOMPtr<nsIDOMNode> brNode;

           res = CreateBR(parentSelectedNode, offsetForInsert+1, address_of(brNode));

           NS_ENSURE_SUCCESS(res, res);

           selection->Collapse(parentSelectedNode, offsetForInsert+1);

         }

       }

     }

   }

   res = mRules->DidDoAction(selection, &ruleInfo, res);

   return res;

 }

 /* 

   InsertNodeAtPoint: attempts to insert aNode into the document, at a point specified by 

       {*ioParent,*ioOffset}.  Checks with strict dtd to see if containment is allowed.  If not

       allowed, will attempt to find a parent in the parent hierarchy of *ioParent that will

       accept aNode as a child.  If such a parent is found, will split the document tree from

       {*ioParent,*ioOffset} up to parent, and then insert aNode.  ioParent & ioOffset are then

       adjusted to point to the actual location that aNode was inserted at.  aNoEmptyNodes

       specifies if the splitting process is allowed to reslt in empty nodes.

               nsIDOMNode            *aNode           node to insert

               nsCOMPtr<nsIDOMNode>  *ioParent        insertion parent

               int32_t               *ioOffset        insertion offset

               bool                  aNoEmptyNodes    splitting can result in empty nodes?

 */

 nsresult

 nsHTMLEditor::InsertNodeAtPoint(nsIDOMNode *aNode, 

                                 nsCOMPtr<nsIDOMNode> *ioParent, 

                                 int32_t *ioOffset, 

                                 bool aNoEmptyNodes)

 {

   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);

   NS_ENSURE_TRUE(ioParent, NS_ERROR_NULL_POINTER);

   NS_ENSURE_TRUE(*ioParent, NS_ERROR_NULL_POINTER);

   NS_ENSURE_TRUE(ioOffset, NS_ERROR_NULL_POINTER);

   nsresult res = NS_OK;

   nsCOMPtr<nsIDOMNode> parent = *ioParent;

   nsCOMPtr<nsIDOMNode> topChild = *ioParent;

   nsCOMPtr<nsIDOMNode> tmp;

   int32_t offsetOfInsert = *ioOffset;

   // Search up the parent chain to find a suitable container      

   while (!CanContain(parent, aNode)) {

     // If the current parent is a root (body or table element)

     // then go no further - we can't insert

     if (nsTextEditUtils::IsBody(parent) || nsHTMLEditUtils::IsTableElement(parent))

       return NS_ERROR_FAILURE;

     // Get the next parent

     parent->GetParentNode(getter_AddRefs(tmp));

     NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);

     topChild = parent;

     parent = tmp;

   }

   if (parent != topChild)

   {

     // we need to split some levels above the original selection parent

     res = SplitNodeDeep(topChild, *ioParent, *ioOffset, &offsetOfInsert, aNoEmptyNodes);

     NS_ENSURE_SUCCESS(res, res);

     *ioParent = parent;

     *ioOffset = offsetOfInsert;

   }

   // Now we can insert the new node

   res = InsertNode(aNode, parent, offsetOfInsert);

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::SelectElement(nsIDOMElement* aElement)

 {

   nsresult res = NS_ERROR_NULL_POINTER;

   // Must be sure that element is contained in the document body

   if (IsDescendantOfEditorRoot(aElement)) {

     nsCOMPtr<nsISelection> selection;

     res = GetSelection(getter_AddRefs(selection));

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

     nsCOMPtr<nsIDOMNode>parent;

     res = aElement->GetParentNode(getter_AddRefs(parent));

     if (NS_SUCCEEDED(res) && parent)

     {

       int32_t offsetInParent = GetChildOffset(aElement, parent);

       // Collapse selection to just before desired element,

       res = selection->Collapse(parent, offsetInParent);

       if (NS_SUCCEEDED(res)) {

         // then extend it to just after

         res = selection->Extend(parent, offsetInParent + 1);

       }

     }

   }

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::SetCaretAfterElement(nsIDOMElement* aElement)

 {

   nsresult res = NS_ERROR_NULL_POINTER;

   // Be sure the element is contained in the document body

   if (aElement && IsDescendantOfEditorRoot(aElement)) {

     nsCOMPtr<nsISelection> selection;

     res = GetSelection(getter_AddRefs(selection));

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

     nsCOMPtr<nsIDOMNode>parent;

     res = aElement->GetParentNode(getter_AddRefs(parent));

     NS_ENSURE_SUCCESS(res, res);

     NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);

     int32_t offsetInParent = GetChildOffset(aElement, parent);

     // Collapse selection to just after desired element,

     res = selection->Collapse(parent, offsetInParent + 1);

   }

   return res;

 }

 NS_IMETHODIMP 

 nsHTMLEditor::SetParagraphFormat(const nsAString& aParagraphFormat)

 {

   nsAutoString tag; tag.Assign(aParagraphFormat);

   ToLowerCase(tag);

   if (tag.EqualsLiteral("dd") || tag.EqualsLiteral("dt"))

     return MakeDefinitionItem(tag);

   else

     return InsertBasicBlock(tag);

 }

 NS_IMETHODIMP 

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

 {

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);

   nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());

   return htmlRules->GetParagraphState(aMixed, outFormat);

 }

 NS_IMETHODIMP

 nsHTMLEditor::GetBackgroundColorState(bool *aMixed, nsAString &aOutColor)

 {

   nsresult res;

   if (IsCSSEnabled()) {

     // if we are in CSS mode, we have to check if the containing block defines

     // a background color

     res = GetCSSBackgroundColorState(aMixed, aOutColor, true);

   }

   else {

     // in HTML mode, we look only at page's background

     res = GetHTMLBackgroundColorState(aMixed, aOutColor);

   }

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::GetHighlightColorState(bool *aMixed, nsAString &aOutColor)

 {

   nsresult res = NS_OK;

   *aMixed = false;

   aOutColor.AssignLiteral("transparent");

   if (IsCSSEnabled()) {

     // in CSS mode, text background can be added by the Text Highlight button

     // we need to query the background of the selection without looking for

     // the block container of the ranges in the selection

     res = GetCSSBackgroundColorState(aMixed, aOutColor, false);

   }

   return res;

 }

 nsresult

 nsHTMLEditor::GetCSSBackgroundColorState(bool *aMixed, nsAString &aOutColor, bool aBlockLevel)

 {

   NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);

   *aMixed = false;

   // the default background color is transparent

   aOutColor.AssignLiteral("transparent");

   // get selection

   nsCOMPtr<nsISelection>selection;

   nsresult res = GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   // get selection location

   nsCOMPtr<nsIDOMNode> parent;

   int32_t offset;

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

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);

   // is the selection collapsed?

   nsCOMPtr<nsIDOMNode> nodeToExamine;

   if (selection->Collapsed() || IsTextNode(parent)) {

     // we want to look at the parent and ancestors

     nodeToExamine = parent;

   } else {

     // otherwise we want to look at the first editable node after

     // {parent,offset} and its ancestors for divs with alignment on them

     nodeToExamine = GetChildAt(parent, offset);

     //GetNextNode(parent, offset, true, address_of(nodeToExamine));

   }

   NS_ENSURE_TRUE(nodeToExamine, NS_ERROR_NULL_POINTER);

   // is the node to examine a block ?

   bool isBlock;

   res = NodeIsBlockStatic(nodeToExamine, &isBlock);

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMNode> tmp;

   if (aBlockLevel) {

     // we are querying the block background (and not the text background), let's

     // climb to the block container

     nsCOMPtr<nsIDOMNode> blockParent = nodeToExamine;

     if (!isBlock) {

       blockParent = GetBlockNodeParent(nodeToExamine);

       NS_ENSURE_TRUE(blockParent, NS_OK);

     }

     // Make sure to not walk off onto the Document node

     nsCOMPtr<nsIDOMElement> element;

     do {

       // retrieve the computed style of background-color for blockParent

       mHTMLCSSUtils->GetComputedProperty(blockParent,

                                          nsEditProperty::cssBackgroundColor,

                                          aOutColor);

       tmp.swap(blockParent);

       res = tmp->GetParentNode(getter_AddRefs(blockParent));

       element = do_QueryInterface(blockParent);

       // look at parent if the queried color is transparent and if the node to

       // examine is not the root of the document

     } while (aOutColor.EqualsLiteral("transparent") && element);

     if (aOutColor.EqualsLiteral("transparent")) {

       // we have hit the root of the document and the color is still transparent !

       // Grumble... Let's look at the default background color because that's the

       // color we are looking for

       mHTMLCSSUtils->GetDefaultBackgroundColor(aOutColor);

     }

   }

   else {

     // no, we are querying the text background for the Text Highlight button

     if (IsTextNode(nodeToExamine)) {

       // if the node of interest is a text node, let's climb a level

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

       NS_ENSURE_SUCCESS(res, res);

       nodeToExamine = parent;

     }

     do {

       // is the node to examine a block ?

       res = NodeIsBlockStatic(nodeToExamine, &isBlock);

       NS_ENSURE_SUCCESS(res, res);

       if (isBlock) {

         // yes it is a block; in that case, the text background color is transparent

         aOutColor.AssignLiteral("transparent");

         break;

       }

       else {

         // no, it's not; let's retrieve the computed style of background-color for the

         // node to examine

         mHTMLCSSUtils->GetComputedProperty(nodeToExamine, nsEditProperty::cssBackgroundColor,

                             aOutColor);

         if (!aOutColor.EqualsLiteral("transparent")) {

           break;

         }

       }

       tmp.swap(nodeToExamine);

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

       NS_ENSURE_SUCCESS(res, res);

     } while ( aOutColor.EqualsLiteral("transparent") && nodeToExamine );

   }

   return NS_OK;

 }

 NS_IMETHODIMP 

 nsHTMLEditor::GetHTMLBackgroundColorState(bool *aMixed, nsAString &aOutColor)

 {

   //TODO: We don't handle "mixed" correctly!

   NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);

   *aMixed = false;

   aOutColor.Truncate();

   nsCOMPtr<nsIDOMElement> domElement;

   int32_t selectedCount;

   nsAutoString tagName;

   nsresult res = GetSelectedOrParentTableElement(tagName,

                                                  &selectedCount,

                                                  getter_AddRefs(domElement));

   NS_ENSURE_SUCCESS(res, res);

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

   while (element) {

     // We are in a cell or selected table

     element->GetAttr(kNameSpaceID_None, nsGkAtoms::bgcolor, aOutColor);

     // Done if we have a color explicitly set

     if (!aOutColor.IsEmpty()) {

       return NS_OK;

     }

     // Once we hit the body, we're done

     if (element->IsHTML(nsGkAtoms::body)) {

       return NS_OK;

     }

     // No color is set, but we need to report visible color inherited 

     // from nested cells/tables, so search up parent chain

     element = element->GetParentElement();

   }

   // If no table or cell found, get page body

   dom::Element* bodyElement = GetRoot();

   NS_ENSURE_TRUE(bodyElement, NS_ERROR_NULL_POINTER);

   bodyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::bgcolor, aOutColor);

   return NS_OK;

 }

 NS_IMETHODIMP 

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

 {

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

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

   nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());

   return htmlRules->GetListState(aMixed, aOL, aUL, aDL);

 }

 NS_IMETHODIMP 

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

 {

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

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

   nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());

   return htmlRules->GetListItemState(aMixed, aLI, aDT, aDD);

 }

 NS_IMETHODIMP

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

 {

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   NS_ENSURE_TRUE(aMixed && aAlign, NS_ERROR_NULL_POINTER);

   nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());

   return htmlRules->GetAlignment(aMixed, aAlign);

 }

 NS_IMETHODIMP 

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

 {

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   NS_ENSURE_TRUE(aCanIndent && aCanOutdent, NS_ERROR_NULL_POINTER);

   nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());

   return htmlRules->GetIndentState(aCanIndent, aCanOutdent);

 }

 NS_IMETHODIMP

 nsHTMLEditor::MakeOrChangeList(const nsAString& aListType, bool entireList, const nsAString& aBulletType)

 {

   nsresult res;

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   // Protect the edit rules object from dying

   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);

   bool cancel, handled;

   nsAutoEditBatch beginBatching(this);

   nsAutoRules beginRulesSniffing(this, EditAction::makeList, nsIEditor::eNext);

   // pre-process

   nsRefPtr<Selection> selection = GetSelection();

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   nsTextRulesInfo ruleInfo(EditAction::makeList);

   ruleInfo.blockType = &aListType;

   ruleInfo.entireList = entireList;

   ruleInfo.bulletType = &aBulletType;

   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);

   if (cancel || (NS_FAILED(res))) return res;

   if (!handled)

   {

     // Find out if the selection is collapsed:

     bool isCollapsed = selection->Collapsed();

     nsCOMPtr<nsIDOMNode> node;

     int32_t offset;

     res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);

     if (!node) res = NS_ERROR_FAILURE;

     NS_ENSURE_SUCCESS(res, res);

     if (isCollapsed)

     {

       // have to find a place to put the list

       nsCOMPtr<nsIDOMNode> parent = node;

       nsCOMPtr<nsIDOMNode> topChild = node;

       nsCOMPtr<nsIDOMNode> tmp;

       nsCOMPtr<nsIAtom> listAtom = do_GetAtom(aListType);

       while (!CanContainTag(parent, listAtom)) {

         parent->GetParentNode(getter_AddRefs(tmp));

         NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);

         topChild = parent;

         parent = tmp;

       }

       if (parent != node)

       {

         // we need to split up to the child of parent

         res = SplitNodeDeep(topChild, node, offset, &offset);

         NS_ENSURE_SUCCESS(res, res);

       }

       // make a list

       nsCOMPtr<nsIDOMNode> newList;

       res = CreateNode(aListType, parent, offset, getter_AddRefs(newList));

       NS_ENSURE_SUCCESS(res, res);

       // make a list item

       nsCOMPtr<nsIDOMNode> newItem;

       res = CreateNode(NS_LITERAL_STRING("li"), newList, 0, getter_AddRefs(newItem));

       NS_ENSURE_SUCCESS(res, res);

       res = selection->Collapse(newItem,0);

       NS_ENSURE_SUCCESS(res, res);

     }

   }

   res = mRules->DidDoAction(selection, &ruleInfo, res);

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::RemoveList(const nsAString& aListType)

 {

   nsresult res;

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   // Protect the edit rules object from dying

   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);

   bool cancel, handled;

   nsAutoEditBatch beginBatching(this);

   nsAutoRules beginRulesSniffing(this, EditAction::removeList, nsIEditor::eNext);

   // pre-process

   nsRefPtr<Selection> selection = GetSelection();

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   nsTextRulesInfo ruleInfo(EditAction::removeList);

   if (aListType.LowerCaseEqualsLiteral("ol"))

     ruleInfo.bOrdered = true;

   else  ruleInfo.bOrdered = false;

   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);

   if (cancel || (NS_FAILED(res))) return res;

   // no default behavior for this yet.  what would it mean?

   res = mRules->DidDoAction(selection, &ruleInfo, res);

   return res;

 }

 nsresult

 nsHTMLEditor::MakeDefinitionItem(const nsAString& aItemType)

 {

   nsresult res;

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   // Protect the edit rules object from dying

   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);

   bool cancel, handled;

   nsAutoEditBatch beginBatching(this);

   nsAutoRules beginRulesSniffing(this, EditAction::makeDefListItem, nsIEditor::eNext);

   // pre-process

   nsRefPtr<Selection> selection = GetSelection();

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   nsTextRulesInfo ruleInfo(EditAction::makeDefListItem);

   ruleInfo.blockType = &aItemType;

   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);

   if (cancel || (NS_FAILED(res))) return res;

   if (!handled)

   {

     // todo: no default for now.  we count on rules to handle it.

   }

   res = mRules->DidDoAction(selection, &ruleInfo, res);

   return res;

 }

 nsresult

 nsHTMLEditor::InsertBasicBlock(const nsAString& aBlockType)

 {

   nsresult res;

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   // Protect the edit rules object from dying

   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);

   bool cancel, handled;

   nsAutoEditBatch beginBatching(this);

   nsAutoRules beginRulesSniffing(this, EditAction::makeBasicBlock, nsIEditor::eNext);

   // pre-process

   nsRefPtr<Selection> selection = GetSelection();

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   nsTextRulesInfo ruleInfo(EditAction::makeBasicBlock);

   ruleInfo.blockType = &aBlockType;

   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);

   if (cancel || (NS_FAILED(res))) return res;

   if (!handled)

   {

     // Find out if the selection is collapsed:

     bool isCollapsed = selection->Collapsed();

     nsCOMPtr<nsIDOMNode> node;

     int32_t offset;

     res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);

     if (!node) res = NS_ERROR_FAILURE;

     NS_ENSURE_SUCCESS(res, res);

     if (isCollapsed)

     {

       // have to find a place to put the block

       nsCOMPtr<nsIDOMNode> parent = node;

       nsCOMPtr<nsIDOMNode> topChild = node;

       nsCOMPtr<nsIDOMNode> tmp;

       nsCOMPtr<nsIAtom> blockAtom = do_GetAtom(aBlockType);

       while (!CanContainTag(parent, blockAtom)) {

         parent->GetParentNode(getter_AddRefs(tmp));

         NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);

         topChild = parent;

         parent = tmp;

       }

       if (parent != node)

       {

         // we need to split up to the child of parent

         res = SplitNodeDeep(topChild, node, offset, &offset);

         NS_ENSURE_SUCCESS(res, res);

       }

       // make a block

       nsCOMPtr<nsIDOMNode> newBlock;

       res = CreateNode(aBlockType, parent, offset, getter_AddRefs(newBlock));

       NS_ENSURE_SUCCESS(res, res);

       // reposition selection to inside the block

       res = selection->Collapse(newBlock,0);

       NS_ENSURE_SUCCESS(res, res);  

     }

   }

   res = mRules->DidDoAction(selection, &ruleInfo, res);

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::Indent(const nsAString& aIndent)

 {

   nsresult res;

   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }

   // Protect the edit rules object from dying

   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);

   bool cancel, handled;

   EditAction opID = EditAction::indent;

   if (aIndent.LowerCaseEqualsLiteral("outdent"))

   {

     opID = EditAction::outdent;

   }

   nsAutoEditBatch beginBatching(this);

   nsAutoRules beginRulesSniffing(this, opID, nsIEditor::eNext);

   // pre-process

   nsRefPtr<Selection> selection = GetSelection();

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   nsTextRulesInfo ruleInfo(opID);

   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);

   if (cancel || (NS_FAILED(res))) return res;

   if (!handled)

   {

     // Do default - insert a blockquote node if selection collapsed

     nsCOMPtr<nsIDOMNode> node;

     int32_t offset;

     bool isCollapsed = selection->Collapsed();

     res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);

     if (!node) res = NS_ERROR_FAILURE;

     NS_ENSURE_SUCCESS(res, res);

     if (aIndent.EqualsLiteral("indent"))

     {

       if (isCollapsed)

       {

         // have to find a place to put the blockquote

         nsCOMPtr<nsIDOMNode> parent = node;

         nsCOMPtr<nsIDOMNode> topChild = node;

         nsCOMPtr<nsIDOMNode> tmp;

         while (!CanContainTag(parent, nsGkAtoms::blockquote)) {

           parent->GetParentNode(getter_AddRefs(tmp));

           NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);

           topChild = parent;

           parent = tmp;

         }

         if (parent != node)

         {

           // we need to split up to the child of parent

           res = SplitNodeDeep(topChild, node, offset, &offset);

           NS_ENSURE_SUCCESS(res, res);

         }

         // make a blockquote

         nsCOMPtr<nsIDOMNode> newBQ;

         res = CreateNode(NS_LITERAL_STRING("blockquote"), parent, offset,

                          getter_AddRefs(newBQ));

         NS_ENSURE_SUCCESS(res, res);

         // put a space in it so layout will draw the list item

         res = selection->Collapse(newBQ,0);

         NS_ENSURE_SUCCESS(res, res);

         res = InsertText(NS_LITERAL_STRING(" "));

         NS_ENSURE_SUCCESS(res, res);

         // reposition selection to before the space character

         res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);

         NS_ENSURE_SUCCESS(res, res);

         res = selection->Collapse(node,0);

         NS_ENSURE_SUCCESS(res, res);

       }

     }

   }

   res = mRules->DidDoAction(selection, &ruleInfo, res);

   return res;

 }

 //TODO: IMPLEMENT ALIGNMENT!

 NS_IMETHODIMP

 nsHTMLEditor::Align(const nsAString& aAlignType)

 {

   // Protect the edit rules object from dying

   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);

   nsAutoEditBatch beginBatching(this);

   nsAutoRules beginRulesSniffing(this, EditAction::align, nsIEditor::eNext);

   nsCOMPtr<nsIDOMNode> node;

   bool cancel, handled;

   // Find out if the selection is collapsed:

   nsRefPtr<Selection> selection = GetSelection();

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   nsTextRulesInfo ruleInfo(EditAction::align);

   ruleInfo.alignType = &aAlignType;

   nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);

   if (cancel || NS_FAILED(res))

     return res;

   res = mRules->DidDoAction(selection, &ruleInfo, res);

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::GetElementOrParentByTagName(const nsAString& aTagName, nsIDOMNode *aNode, nsIDOMElement** aReturn)

 {

   NS_ENSURE_TRUE(!aTagName.IsEmpty(), NS_ERROR_NULL_POINTER);

   NS_ENSURE_TRUE(aReturn, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsINode> current = do_QueryInterface(aNode);

   if (!current) {

     // If no node supplied, get it from anchor node of current selection

     nsRefPtr<Selection> selection = GetSelection();

     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

     nsCOMPtr<nsINode> anchorNode = selection->GetAnchorNode();

     NS_ENSURE_TRUE(anchorNode, NS_ERROR_FAILURE);

     // Try to get the actual selected node

     if (anchorNode->HasChildNodes() && anchorNode->IsContent()) {

       uint32_t offset = selection->AnchorOffset();

       current = anchorNode->GetChildAt(offset);

     }

     // anchor node is probably a text node - just use that

     if (!current) {

       current = anchorNode;

     }

   }

   nsCOMPtr<nsIDOMNode> currentNode = current->AsDOMNode();

   nsAutoString TagName(aTagName);

   ToLowerCase(TagName);

   bool getLink = IsLinkTag(TagName);

   bool getNamedAnchor = IsNamedAnchorTag(TagName);

   if ( getLink || getNamedAnchor)

   {

     TagName.AssignLiteral("a");  

   }

   bool findTableCell = TagName.EqualsLiteral("td");

   bool findList = TagName.EqualsLiteral("list");

   // default is null - no element found

   *aReturn = nullptr;

   nsCOMPtr<nsIDOMNode> parent;

   bool bNodeFound = false;

   while (true)

   {

     nsAutoString currentTagName; 

     // Test if we have a link (an anchor with href set)

     if ( (getLink && nsHTMLEditUtils::IsLink(currentNode)) ||

          (getNamedAnchor && nsHTMLEditUtils::IsNamedAnchor(currentNode)) )

     {

       bNodeFound = true;

       break;

     } else {

       if (findList)

       {

         // Match "ol", "ul", or "dl" for lists

         if (nsHTMLEditUtils::IsList(currentNode))

           goto NODE_FOUND;

       } else if (findTableCell)

       {

         // Table cells are another special case:

         // Match either "td" or "th" for them

         if (nsHTMLEditUtils::IsTableCell(currentNode))

           goto NODE_FOUND;

       } else {

         currentNode->GetNodeName(currentTagName);

         if (currentTagName.Equals(TagName, nsCaseInsensitiveStringComparator()))

         {

 NODE_FOUND:

           bNodeFound = true;

           break;

         } 

       }

     }

     // Search up the parent chain

     // We should never fail because of root test below, but lets be safe

     // XXX: ERROR_HANDLING error return code lost

     if (NS_FAILED(currentNode->GetParentNode(getter_AddRefs(parent))) || !parent)

       break;

     // Stop searching if parent is a body tag

     nsAutoString parentTagName;

     parent->GetNodeName(parentTagName);

     // Note: Originally used IsRoot to stop at table cells,

     //  but that's too messy when you are trying to find the parent table

     if(parentTagName.LowerCaseEqualsLiteral("body"))

       break;

     currentNode = parent;

   }

   if (!bNodeFound) {

     return NS_EDITOR_ELEMENT_NOT_FOUND;

   }

   nsCOMPtr<nsIDOMElement> currentElement = do_QueryInterface(currentNode);

   currentElement.forget(aReturn);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsHTMLEditor::GetSelectedElement(const nsAString& aTagName, nsIDOMElement** aReturn)

 {

   NS_ENSURE_TRUE(aReturn , NS_ERROR_NULL_POINTER);

   // default is null - no element found

   *aReturn = nullptr;

   // First look for a single element in selection

   nsCOMPtr<nsISelection>selection;

   nsresult res = GetSelection(getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(res, res);

   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);

   Selection* sel = static_cast<Selection*>(selection.get());

   bool bNodeFound = false;

   bool isCollapsed = selection->Collapsed();

   nsAutoString domTagName;

   nsAutoString TagName(aTagName);

   ToLowerCase(TagName);

   // Empty string indicates we should match any element tag

   bool anyTag = (TagName.IsEmpty());

   bool isLinkTag = IsLinkTag(TagName);

   bool isNamedAnchorTag = IsNamedAnchorTag(TagName);

   nsCOMPtr<nsIDOMElement> selectedElement;

   nsCOMPtr<nsIDOMRange> range;

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

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMNode> startParent;

   int32_t startOffset, endOffset;

   res = range->GetStartContainer(getter_AddRefs(startParent));

   NS_ENSURE_SUCCESS(res, res);

   res = range->GetStartOffset(&startOffset);

   NS_ENSURE_SUCCESS(res, res);

   nsCOMPtr<nsIDOMNode> endParent;

   res = range->GetEndContainer(getter_AddRefs(endParent));

   NS_ENSURE_SUCCESS(res, res);

   res = range->GetEndOffset(&endOffset);

   NS_ENSURE_SUCCESS(res, res);

   // Optimization for a single selected element

   if (startParent && startParent == endParent && (endOffset-startOffset) == 1)

   {

     nsCOMPtr<nsIDOMNode> selectedNode = GetChildAt(startParent, startOffset);

     NS_ENSURE_SUCCESS(res, NS_OK);

     if (selectedNode)

     {

       selectedNode->GetNodeName(domTagName);

       ToLowerCase(domTagName);

       // Test for appropriate node type requested

       if (anyTag || (TagName == domTagName) ||

           (isLinkTag && nsHTMLEditUtils::IsLink(selectedNode)) ||

           (isNamedAnchorTag && nsHTMLEditUtils::IsNamedAnchor(selectedNode)))

       {

         bNodeFound = true;

         selectedElement = do_QueryInterface(selectedNode);

       }

     }

   }

   if (!bNodeFound)

   {

     if (isLinkTag)

     {

       // Link tag is a special case - we return the anchor node

       //  found for any selection that is totally within a link,

       //  included a collapsed selection (just a caret in a link)

       nsCOMPtr<nsIDOMNode> anchorNode;

       res = selection->GetAnchorNode(getter_AddRefs(anchorNode));

       NS_ENSURE_SUCCESS(res, res);

       int32_t anchorOffset = -1;

       if (anchorNode)

         selection->GetAnchorOffset(&anchorOffset);

       nsCOMPtr<nsIDOMNode> focusNode;

       res = selection->GetFocusNode(getter_AddRefs(focusNode));

       NS_ENSURE_SUCCESS(res, res);

       int32_t focusOffset = -1;

       if (focusNode)

         selection->GetFocusOffset(&focusOffset);

       // Link node must be the same for both ends of selection

       if (NS_SUCCEEDED(res) && anchorNode)

       {

         nsCOMPtr<nsIDOMElement> parentLinkOfAnchor;

         res = GetElementOrParentByTagName(NS_LITERAL_STRING("href"), anchorNode, getter_AddRefs(parentLinkOfAnchor));

         // XXX: ERROR_HANDLING  can parentLinkOfAnchor be null?

         if (NS_SUCCEEDED(res) && parentLinkOfAnchor)

         {

           if (isCollapsed)

           {

             // We have just a caret in the link

             bNodeFound = true;

           } else if(focusNode) 

           {  // Link node must be the same for both ends of selection

             nsCOMPtr<nsIDOMElement> parentLinkOfFocus;

             res = GetElementOrParentByTagName(NS_LITERAL_STRING("href"), focusNode, getter_AddRefs(parentLinkOfFocus));

             if (NS_SUCCEEDED(res) && parentLinkOfFocus == parentLinkOfAnchor)

               bNodeFound = true;

           }

           // We found a link node parent

           if (bNodeFound) {

             // GetElementOrParentByTagName addref'd this, so we don't need to do it here

             *aReturn = parentLinkOfAnchor;

             NS_IF_ADDREF(*aReturn);

             return NS_OK;

           }

         }

         else if (anchorOffset >= 0)  // Check if link node is the only thing selected

         {

           nsCOMPtr<nsIDOMNode> anchorChild;

           anchorChild = GetChildAt(anchorNode,anchorOffset);

           if (anchorChild && nsHTMLEditUtils::IsLink(anchorChild) && 

               (anchorNode == focusNode) && focusOffset == (anchorOffset+1))

           {

             selectedElement = do_QueryInterface(anchorChild);

             bNodeFound = true;

           }

         }

       }

     } 

     if (!isCollapsed)   // Don't bother to examine selection if it is collapsed

     {

       nsRefPtr<nsRange> currange = sel->GetRangeAt(0);

       if (currange) {

         nsCOMPtr<nsIContentIterator> iter =

           do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &res);

         NS_ENSURE_SUCCESS(res, res);

         iter->Init(currange);

         // loop through the content iterator for each content node

         while (!iter->IsDone())

         {

           // Query interface to cast nsIContent to nsIDOMNode

           //  then get tagType to compare to  aTagName

           // Clone node of each desired type and append it to the aDomFrag

           selectedElement = do_QueryInterface(iter->GetCurrentNode());

           if (selectedElement)

           {

             // If we already found a node, then we have another element,

             //  thus there's not just one element selected

             if (bNodeFound)

             {

               bNodeFound = false;

               break;

             }

             selectedElement->GetNodeName(domTagName);

             ToLowerCase(domTagName);

             if (anyTag)

             {

               // Get name of first selected element

               selectedElement->GetTagName(TagName);

               ToLowerCase(TagName);

               anyTag = false;

             }

             // The "A" tag is a pain,

             //  used for both link(href is set) and "Named Anchor"

             nsCOMPtr<nsIDOMNode> selectedNode = do_QueryInterface(selectedElement);

             if ( (isLinkTag && nsHTMLEditUtils::IsLink(selectedNode)) ||

                 (isNamedAnchorTag && nsHTMLEditUtils::IsNamedAnchor(selectedNode)) )

             {

               bNodeFound = true;

             } else if (TagName == domTagName) { // All other tag names are handled here

               bNodeFound = true;

             }

             if (!bNodeFound)

             {

               // Check if node we have is really part of the selection???

               break;

             }

           }

           iter->Next();

         }

       } else {

         // Should never get here?

         isCollapsed = true;

         NS_WARNING("isCollapsed was FALSE, but no elements found in selection\n");

       }

     }

   }

   if (bNodeFound)

   {

     *aReturn = selectedElement;

     if (selectedElement)

     {  

       // Getters must addref

       NS_ADDREF(*aReturn);

     }

   } 

   else res = NS_EDITOR_ELEMENT_NOT_FOUND;

   return res;

 }

 NS_IMETHODIMP

 nsHTMLEditor::CreateElementWithDefaults(const nsAString& aTagName, nsIDOMElement** aReturn)

 {

   nsresult res=NS_ERROR_NOT_INITIALIZED;

   if (aReturn)

     *aReturn = nullptr;

 //  NS_ENSURE_TRUE(aTagName && aReturn, NS_ERROR_NULL_POINTER);

   NS_ENSURE_TRUE(!aTagName.IsEmpty() && aReturn, NS_ERROR_NULL_POINTER);

   nsAutoString TagName(aTagName);

   ToLowerCase(TagName);

   nsAutoString realTagName;

   if (IsLinkTag(TagName) || IsNamedAnchorTag(TagName))

   {

     realTagName.AssignLiteral("a");

   } else {

     realTagName = TagName;

   }

   //We don't use editor's CreateElement because we don't want to 

   //  go through the transaction system

   nsCOMPtr<nsIDOMElement>newElement;

   nsCOMPtr<dom::Element> newContent;

   nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);

   NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);

   //new call to use instead to get proper HTML element, bug# 39919

   res = CreateHTMLContent(realTagName, getter_AddRefs(newContent));

   newElement = do_QueryInterface(newContent);

   if (NS_FAILED(res) || !newElement)

     return NS_ERROR_FAILURE;

   // Mark the new element dirty, so it will be formatted

   newElement->SetAttribute(NS_LITERAL_STRING("_moz_dirty"), EmptyString());

   // Set default values for new elements

   if (TagName.EqualsLiteral("table")) {

     res = newElement->SetAttribute(NS_LITERAL_STRING("cellpadding"),NS_LITERAL_STRING("2"));

     NS_ENSURE_SUCCESS(res, res);

     res = newElement->SetAttribute(NS_LITERAL_STRING("cellspacing"),NS_LITERAL_STRING("2"));

     NS_ENSURE_SUCCESS(res, res);

     res = newElement->SetAttribute(NS_LITERAL_STRING("border"),NS_LITERAL_STRING("1"));

   } else if (TagName.EqualsLiteral("td"))

   {

     res = SetAttributeOrEquivalent(newElement, NS_LITERAL_STRING("valign"),

                                    NS_LITERAL_STRING("top"), true);

   }

   // ADD OTHER TAGS HERE

   if (NS_SUCCEEDED(res))

   {

     *aReturn = newElement;

     // Getters must addref

     NS_ADDREF(*aReturn);

   }

   return res;

 }