/* -*- 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/TextEditor.h" #include "InternetCiter.h" #include "TextEditUtils.h" #include "gfxFontUtils.h" #include "mozilla/Assertions.h" #include "mozilla/EditorUtils.h" // AutoEditBatch, AutoRules #include "mozilla/mozalloc.h" #include "mozilla/Preferences.h" #include "mozilla/TextEditRules.h" #include "mozilla/TextComposition.h" #include "mozilla/TextEvents.h" #include "mozilla/dom/Selection.h" #include "mozilla/dom/Event.h" #include "mozilla/dom/Element.h" #include "nsAString.h" #include "nsCRT.h" #include "nsCaret.h" #include "nsCharTraits.h" #include "nsComponentManagerUtils.h" #include "nsContentCID.h" #include "nsCopySupport.h" #include "nsDebug.h" #include "nsDependentSubstring.h" #include "nsError.h" #include "nsGkAtoms.h" #include "nsIClipboard.h" #include "nsIContent.h" #include "nsIContentIterator.h" #include "nsIDOMCharacterData.h" #include "nsIDOMDocument.h" #include "nsIDOMElement.h" #include "nsIDOMEventTarget.h" #include "nsIDOMKeyEvent.h" #include "nsIDOMNode.h" #include "nsIDOMNodeList.h" #include "nsIDocumentEncoder.h" #include "nsIEditorIMESupport.h" #include "nsIEditRules.h" #include "nsINode.h" #include "nsIPresShell.h" #include "nsISelectionController.h" #include "nsISupportsPrimitives.h" #include "nsITransferable.h" #include "nsIWeakReferenceUtils.h" #include "nsNameSpaceManager.h" #include "nsLiteralString.h" #include "nsReadableUtils.h" #include "nsServiceManagerUtils.h" #include "nsString.h" #include "nsStringFwd.h" #include "nsSubstringTuple.h" #include "nsUnicharUtils.h" #include "nsXPCOM.h" class nsIOutputStream; class nsISupports; namespace mozilla { using namespace dom; TextEditor::TextEditor() : mWrapColumn(0) , mMaxTextLength(-1) , mInitTriggerCounter(0) , mNewlineHandling(nsIPlaintextEditor::eNewlinesPasteToFirst) #ifdef XP_WIN , mCaretStyle(1) #else , mCaretStyle(0) #endif { // check the "single line editor newline handling" // and "caret behaviour in selection" prefs GetDefaultEditorPrefs(mNewlineHandling, mCaretStyle); } TextEditor::~TextEditor() { // Remove event listeners. Note that if we had an HTML editor, // it installed its own instead of these RemoveEventListeners(); if (mRules) mRules->DetachEditor(); } NS_IMPL_CYCLE_COLLECTION_CLASS(TextEditor) NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(TextEditor, EditorBase) if (tmp->mRules) tmp->mRules->DetachEditor(); NS_IMPL_CYCLE_COLLECTION_UNLINK(mRules) NS_IMPL_CYCLE_COLLECTION_UNLINK_END NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(TextEditor, EditorBase) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRules) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END NS_IMPL_ADDREF_INHERITED(TextEditor, EditorBase) NS_IMPL_RELEASE_INHERITED(TextEditor, EditorBase) NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(TextEditor) NS_INTERFACE_MAP_ENTRY(nsIPlaintextEditor) NS_INTERFACE_MAP_ENTRY(nsIEditorMailSupport) NS_INTERFACE_MAP_END_INHERITING(EditorBase) NS_IMETHODIMP TextEditor::Init(nsIDOMDocument* aDoc, nsIContent* aRoot, nsISelectionController* aSelCon, uint32_t aFlags, const nsAString& aInitialValue) { NS_PRECONDITION(aDoc, "bad arg"); NS_ENSURE_TRUE(aDoc, NS_ERROR_NULL_POINTER); if (mRules) { mRules->DetachEditor(); } nsresult rulesRv = NS_OK; { // block to scope AutoEditInitRulesTrigger AutoEditInitRulesTrigger rulesTrigger(this, rulesRv); // Init the base editor nsresult rv = EditorBase::Init(aDoc, aRoot, aSelCon, aFlags, aInitialValue); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } } NS_ENSURE_SUCCESS(rulesRv, rulesRv); // mRules may not have been initialized yet, when this is called via // HTMLEditor::Init. if (mRules) { mRules->SetInitialValue(aInitialValue); } return NS_OK; } static int32_t sNewlineHandlingPref = -1, sCaretStylePref = -1; static void EditorPrefsChangedCallback(const char* aPrefName, void *) { if (!nsCRT::strcmp(aPrefName, "editor.singleLine.pasteNewlines")) { sNewlineHandlingPref = Preferences::GetInt("editor.singleLine.pasteNewlines", nsIPlaintextEditor::eNewlinesPasteToFirst); } else if (!nsCRT::strcmp(aPrefName, "layout.selection.caret_style")) { sCaretStylePref = Preferences::GetInt("layout.selection.caret_style", #ifdef XP_WIN 1); if (!sCaretStylePref) { sCaretStylePref = 1; } #else 0); #endif } } // static void TextEditor::GetDefaultEditorPrefs(int32_t& aNewlineHandling, int32_t& aCaretStyle) { if (sNewlineHandlingPref == -1) { Preferences::RegisterCallback(EditorPrefsChangedCallback, "editor.singleLine.pasteNewlines"); EditorPrefsChangedCallback("editor.singleLine.pasteNewlines", nullptr); Preferences::RegisterCallback(EditorPrefsChangedCallback, "layout.selection.caret_style"); EditorPrefsChangedCallback("layout.selection.caret_style", nullptr); } aNewlineHandling = sNewlineHandlingPref; aCaretStyle = sCaretStylePref; } void TextEditor::BeginEditorInit() { mInitTriggerCounter++; } nsresult TextEditor::EndEditorInit() { NS_PRECONDITION(mInitTriggerCounter > 0, "ended editor init before we began?"); mInitTriggerCounter--; if (mInitTriggerCounter) { return NS_OK; } nsresult rv = InitRules(); if (NS_FAILED(rv)) { return rv; } // Throw away the old transaction manager if this is not the first time that // we're initializing the editor. EnableUndo(false); EnableUndo(true); return NS_OK; } NS_IMETHODIMP TextEditor::SetDocumentCharacterSet(const nsACString& characterSet) { nsresult rv = EditorBase::SetDocumentCharacterSet(characterSet); NS_ENSURE_SUCCESS(rv, rv); // Update META charset element. nsCOMPtr<nsIDOMDocument> domdoc = GetDOMDocument(); NS_ENSURE_TRUE(domdoc, NS_ERROR_NOT_INITIALIZED); if (UpdateMetaCharset(domdoc, characterSet)) { return NS_OK; } nsCOMPtr<nsIDOMNodeList> headList; rv = domdoc->GetElementsByTagName(NS_LITERAL_STRING("head"), getter_AddRefs(headList)); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(headList, NS_OK); nsCOMPtr<nsIDOMNode> headNode; headList->Item(0, getter_AddRefs(headNode)); NS_ENSURE_TRUE(headNode, NS_OK); // Create a new meta charset tag nsCOMPtr<nsIDOMNode> resultNode; rv = CreateNode(NS_LITERAL_STRING("meta"), headNode, 0, getter_AddRefs(resultNode)); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); NS_ENSURE_TRUE(resultNode, NS_OK); // Set attributes to the created element if (characterSet.IsEmpty()) { return NS_OK; } nsCOMPtr<dom::Element> metaElement = do_QueryInterface(resultNode); if (!metaElement) { return NS_OK; } // not undoable, undo should undo CreateNode metaElement->SetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, NS_LITERAL_STRING("Content-Type"), true); metaElement->SetAttr(kNameSpaceID_None, nsGkAtoms::content, NS_LITERAL_STRING("text/html;charset=") + NS_ConvertASCIItoUTF16(characterSet), true); return NS_OK; } bool TextEditor::UpdateMetaCharset(nsIDOMDocument* aDocument, const nsACString& aCharacterSet) { MOZ_ASSERT(aDocument); // get a list of META tags nsCOMPtr<nsIDOMNodeList> list; nsresult rv = aDocument->GetElementsByTagName(NS_LITERAL_STRING("meta"), getter_AddRefs(list)); NS_ENSURE_SUCCESS(rv, false); NS_ENSURE_TRUE(list, false); nsCOMPtr<nsINodeList> metaList = do_QueryInterface(list); uint32_t listLength = 0; metaList->GetLength(&listLength); for (uint32_t i = 0; i < listLength; ++i) { nsCOMPtr<nsIContent> metaNode = metaList->Item(i); MOZ_ASSERT(metaNode); if (!metaNode->IsElement()) { continue; } nsAutoString currentValue; metaNode->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, currentValue); if (!FindInReadable(NS_LITERAL_STRING("content-type"), currentValue, nsCaseInsensitiveStringComparator())) { continue; } metaNode->GetAttr(kNameSpaceID_None, nsGkAtoms::content, currentValue); NS_NAMED_LITERAL_STRING(charsetEquals, "charset="); nsAString::const_iterator originalStart, start, end; originalStart = currentValue.BeginReading(start); currentValue.EndReading(end); if (!FindInReadable(charsetEquals, start, end, nsCaseInsensitiveStringComparator())) { continue; } // set attribute to <original prefix> charset=text/html nsCOMPtr<nsIDOMElement> metaElement = do_QueryInterface(metaNode); MOZ_ASSERT(metaElement); rv = EditorBase::SetAttribute(metaElement, NS_LITERAL_STRING("content"), Substring(originalStart, start) + charsetEquals + NS_ConvertASCIItoUTF16(aCharacterSet)); return NS_SUCCEEDED(rv); } return false; } NS_IMETHODIMP TextEditor::InitRules() { if (!mRules) { // instantiate the rules for this text editor mRules = new TextEditRules(); } return mRules->Init(this); } NS_IMETHODIMP TextEditor::GetIsDocumentEditable(bool* aIsDocumentEditable) { NS_ENSURE_ARG_POINTER(aIsDocumentEditable); nsCOMPtr<nsIDOMDocument> doc = GetDOMDocument(); *aIsDocumentEditable = doc && IsModifiable(); return NS_OK; } bool TextEditor::IsModifiable() { return !IsReadonly(); } nsresult TextEditor::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent) { // NOTE: When you change this method, you should also change: // * editor/libeditor/tests/test_texteditor_keyevent_handling.html // * editor/libeditor/tests/test_htmleditor_keyevent_handling.html // // And also when you add new key handling, you need to change the subclass's // HandleKeyPressEvent()'s switch statement. if (IsReadonly() || IsDisabled()) { // When we're not editable, the events handled on EditorBase. return EditorBase::HandleKeyPressEvent(aKeyEvent); } WidgetKeyboardEvent* nativeKeyEvent = aKeyEvent->AsEvent()->WidgetEventPtr()->AsKeyboardEvent(); NS_ENSURE_TRUE(nativeKeyEvent, NS_ERROR_UNEXPECTED); NS_ASSERTION(nativeKeyEvent->mMessage == eKeyPress, "HandleKeyPressEvent gets non-keypress event"); switch (nativeKeyEvent->mKeyCode) { case NS_VK_META: case NS_VK_WIN: case NS_VK_SHIFT: case NS_VK_CONTROL: case NS_VK_ALT: case NS_VK_BACK: case NS_VK_DELETE: // These keys are handled on EditorBase return EditorBase::HandleKeyPressEvent(aKeyEvent); case NS_VK_TAB: { if (IsTabbable()) { return NS_OK; // let it be used for focus switching } if (nativeKeyEvent->IsShift() || nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() || nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) { return NS_OK; } // else we insert the tab straight through aKeyEvent->AsEvent()->PreventDefault(); return TypedText(NS_LITERAL_STRING("\t"), eTypedText); } case NS_VK_RETURN: if (IsSingleLineEditor() || nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() || nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) { return NS_OK; } aKeyEvent->AsEvent()->PreventDefault(); 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->mCharCode || 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->AsEvent()->PreventDefault(); nsAutoString str(nativeKeyEvent->mCharCode); return TypedText(str, eTypedText); } /* 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 TextEditor::TypedText(const nsAString& aString, ETypingAction aAction) { AutoPlaceHolderBatch batch(this, nsGkAtoms::TypingTxnName); switch (aAction) { case eTypedText: return InsertText(aString); case eTypedBreak: return InsertLineBreak(); default: // eTypedBR is only for HTML return NS_ERROR_FAILURE; } } already_AddRefed<Element> TextEditor::CreateBRImpl(nsCOMPtr<nsINode>* aInOutParent, int32_t* aInOutOffset, EDirection aSelect) { nsCOMPtr<nsIDOMNode> parent(GetAsDOMNode(*aInOutParent)); nsCOMPtr<nsIDOMNode> br; // We ignore the retval, and assume it's fine if the br is non-null CreateBRImpl(address_of(parent), aInOutOffset, address_of(br), aSelect); *aInOutParent = do_QueryInterface(parent); nsCOMPtr<Element> ret(do_QueryInterface(br)); return ret.forget(); } nsresult TextEditor::CreateBRImpl(nsCOMPtr<nsIDOMNode>* aInOutParent, int32_t* aInOutOffset, nsCOMPtr<nsIDOMNode>* outBRNode, EDirection aSelect) { NS_ENSURE_TRUE(aInOutParent && *aInOutParent && aInOutOffset && outBRNode, NS_ERROR_NULL_POINTER); *outBRNode = nullptr; // we need to insert a br. unfortunately, we may have to split a text node to do it. nsCOMPtr<nsIDOMNode> node = *aInOutParent; int32_t theOffset = *aInOutOffset; nsCOMPtr<nsIDOMCharacterData> nodeAsText = do_QueryInterface(node); NS_NAMED_LITERAL_STRING(brType, "br"); nsCOMPtr<nsIDOMNode> brNode; if (nodeAsText) { int32_t offset; uint32_t len; nodeAsText->GetLength(&len); nsCOMPtr<nsIDOMNode> tmp = GetNodeLocation(node, &offset); NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE); if (!theOffset) { // we are already set to go } else if (theOffset == (int32_t)len) { // update offset to point AFTER the text node offset++; } else { // split the text node nsresult rv = SplitNode(node, theOffset, getter_AddRefs(tmp)); NS_ENSURE_SUCCESS(rv, rv); tmp = GetNodeLocation(node, &offset); } // create br nsresult rv = CreateNode(brType, tmp, offset, getter_AddRefs(brNode)); NS_ENSURE_SUCCESS(rv, rv); *aInOutParent = tmp; *aInOutOffset = offset+1; } else { nsresult rv = CreateNode(brType, node, theOffset, getter_AddRefs(brNode)); NS_ENSURE_SUCCESS(rv, rv); (*aInOutOffset)++; } *outBRNode = brNode; if (*outBRNode && (aSelect != eNone)) { int32_t offset; nsCOMPtr<nsIDOMNode> parent = GetNodeLocation(*outBRNode, &offset); RefPtr<Selection> selection = GetSelection(); NS_ENSURE_STATE(selection); if (aSelect == eNext) { // position selection after br selection->SetInterlinePosition(true); selection->Collapse(parent, offset + 1); } else if (aSelect == ePrevious) { // position selection before br selection->SetInterlinePosition(true); selection->Collapse(parent, offset); } } return NS_OK; } NS_IMETHODIMP TextEditor::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 TextEditor::InsertBR(nsCOMPtr<nsIDOMNode>* outBRNode) { NS_ENSURE_TRUE(outBRNode, NS_ERROR_NULL_POINTER); *outBRNode = nullptr; // calling it text insertion to trigger moz br treatment by rules AutoRules beginRulesSniffing(this, EditAction::insertText, nsIEditor::eNext); RefPtr<Selection> selection = GetSelection(); NS_ENSURE_STATE(selection); if (!selection->Collapsed()) { nsresult rv = DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip); NS_ENSURE_SUCCESS(rv, rv); } nsCOMPtr<nsIDOMNode> selNode; int32_t selOffset; nsresult rv = GetStartNodeAndOffset(selection, getter_AddRefs(selNode), &selOffset); NS_ENSURE_SUCCESS(rv, rv); rv = CreateBR(selNode, selOffset, outBRNode); NS_ENSURE_SUCCESS(rv, rv); // position selection after br selNode = GetNodeLocation(*outBRNode, &selOffset); selection->SetInterlinePosition(true); return selection->Collapse(selNode, selOffset+1); } nsresult TextEditor::ExtendSelectionForDelete(Selection* aSelection, nsIEditor::EDirection* aAction) { bool bCollapsed = aSelection->Collapsed(); if (*aAction == eNextWord || *aAction == ePreviousWord || (*aAction == eNext && bCollapsed) || (*aAction == ePrevious && bCollapsed) || *aAction == eToBeginningOfLine || *aAction == eToEndOfLine) { nsCOMPtr<nsISelectionController> selCont; GetSelectionController(getter_AddRefs(selCont)); NS_ENSURE_TRUE(selCont, NS_ERROR_NO_INTERFACE); nsresult rv; switch (*aAction) { case eNextWord: rv = selCont->WordExtendForDelete(true); // DeleteSelectionImpl doesn't handle these actions // because it's inside batching, so don't confuse it: *aAction = eNone; break; case ePreviousWord: rv = selCont->WordExtendForDelete(false); *aAction = eNone; break; case eNext: rv = selCont->CharacterExtendForDelete(); // Don't set aAction to eNone (see Bug 502259) break; case ePrevious: { // Only extend the selection where the selection is after a UTF-16 // surrogate pair or a variation selector. // For other cases we don't want to do that, in order // to make sure that pressing backspace will only delete the last // typed character. nsCOMPtr<nsIDOMNode> node; int32_t offset; rv = GetStartNodeAndOffset(aSelection, getter_AddRefs(node), &offset); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(node, NS_ERROR_FAILURE); // node might be anonymous DIV, so we find better text node FindBetterInsertionPoint(node, offset); if (IsTextNode(node)) { nsCOMPtr<nsIDOMCharacterData> charData = do_QueryInterface(node); if (charData) { nsAutoString data; rv = charData->GetData(data); NS_ENSURE_SUCCESS(rv, rv); if ((offset > 1 && NS_IS_LOW_SURROGATE(data[offset - 1]) && NS_IS_HIGH_SURROGATE(data[offset - 2])) || (offset > 0 && gfxFontUtils::IsVarSelector(data[offset - 1]))) { rv = selCont->CharacterExtendForBackspace(); } } } break; } case eToBeginningOfLine: selCont->IntraLineMove(true, false); // try to move to end rv = selCont->IntraLineMove(false, true); // select to beginning *aAction = eNone; break; case eToEndOfLine: rv = selCont->IntraLineMove(true, true); *aAction = eNext; break; default: // avoid several compiler warnings rv = NS_OK; break; } return rv; } return NS_OK; } nsresult TextEditor::DeleteSelection(EDirection aAction, EStripWrappers aStripWrappers) { MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip); if (!mRules) { return NS_ERROR_NOT_INITIALIZED; } // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); // delete placeholder txns merge. AutoPlaceHolderBatch batch(this, nsGkAtoms::DeleteTxnName); AutoRules beginRulesSniffing(this, EditAction::deleteSelection, aAction); // pre-process RefPtr<Selection> selection = GetSelection(); NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER); // If there is an existing selection when an extended delete is requested, // platforms that use "caret-style" caret positioning collapse the // selection to the start and then create a new selection. // Platforms that use "selection-style" caret positioning just delete the // existing selection without extending it. if (!selection->Collapsed() && (aAction == eNextWord || aAction == ePreviousWord || aAction == eToBeginningOfLine || aAction == eToEndOfLine)) { if (mCaretStyle == 1) { nsresult rv = selection->CollapseToStart(); NS_ENSURE_SUCCESS(rv, rv); } else { aAction = eNone; } } TextRulesInfo ruleInfo(EditAction::deleteSelection); ruleInfo.collapsedAction = aAction; ruleInfo.stripWrappers = aStripWrappers; bool cancel, handled; nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled); NS_ENSURE_SUCCESS(rv, rv); if (!cancel && !handled) { rv = DeleteSelectionImpl(aAction, aStripWrappers); } if (!cancel) { // post-process rv = rules->DidDoAction(selection, &ruleInfo, rv); } return rv; } NS_IMETHODIMP TextEditor::InsertText(const nsAString& aStringToInsert) { if (!mRules) { return NS_ERROR_NOT_INITIALIZED; } // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); EditAction opID = EditAction::insertText; if (ShouldHandleIMEComposition()) { opID = EditAction::insertIMEText; } AutoPlaceHolderBatch batch(this, nullptr); AutoRules beginRulesSniffing(this, opID, nsIEditor::eNext); // pre-process RefPtr<Selection> selection = GetSelection(); NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER); nsAutoString resultString; // XXX can we trust instring to outlive ruleInfo, // XXX and ruleInfo not to refer to instring in its dtor? //nsAutoString instring(aStringToInsert); TextRulesInfo ruleInfo(opID); ruleInfo.inString = &aStringToInsert; ruleInfo.outString = &resultString; ruleInfo.maxLength = mMaxTextLength; bool cancel, handled; nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled); NS_ENSURE_SUCCESS(rv, rv); if (!cancel && !handled) { // we rely on rules code for now - no default implementation } if (cancel) { return NS_OK; } // post-process return rules->DidDoAction(selection, &ruleInfo, rv); } NS_IMETHODIMP TextEditor::InsertLineBreak() { if (!mRules) { return NS_ERROR_NOT_INITIALIZED; } // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); AutoEditBatch beginBatching(this); AutoRules beginRulesSniffing(this, EditAction::insertBreak, nsIEditor::eNext); // pre-process RefPtr<Selection> selection = GetSelection(); NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER); TextRulesInfo ruleInfo(EditAction::insertBreak); ruleInfo.maxLength = mMaxTextLength; bool cancel, handled; nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled); NS_ENSURE_SUCCESS(rv, rv); if (!cancel && !handled) { // get the (collapsed) selection location NS_ENSURE_STATE(selection->GetRangeAt(0)); nsCOMPtr<nsINode> selNode = selection->GetRangeAt(0)->GetStartParent(); int32_t selOffset = selection->GetRangeAt(0)->StartOffset(); NS_ENSURE_STATE(selNode); // don't put text in places that can't have it if (!IsTextNode(selNode) && !CanContainTag(*selNode, *nsGkAtoms::textTagName)) { return NS_ERROR_FAILURE; } // we need to get the doc nsCOMPtr<nsIDocument> doc = GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED); // don't spaz my selection in subtransactions AutoTransactionsConserveSelection dontSpazMySelection(this); // insert a linefeed character rv = InsertTextImpl(NS_LITERAL_STRING("\n"), address_of(selNode), &selOffset, doc); if (!selNode) { rv = NS_ERROR_NULL_POINTER; // don't return here, so DidDoAction is called } if (NS_SUCCEEDED(rv)) { // set the selection to the correct location rv = selection->Collapse(selNode, selOffset); if (NS_SUCCEEDED(rv)) { // see if we're at the end of the editor range nsCOMPtr<nsIDOMNode> endNode; int32_t endOffset; rv = GetEndNodeAndOffset(selection, getter_AddRefs(endNode), &endOffset); if (NS_SUCCEEDED(rv) && endNode == GetAsDOMNode(selNode) && endOffset == selOffset) { // 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. selection->SetInterlinePosition(true); } } } } if (!cancel) { // post-process, always called if WillInsertBreak didn't return cancel==true rv = rules->DidDoAction(selection, &ruleInfo, rv); } return rv; } nsresult TextEditor::BeginIMEComposition(WidgetCompositionEvent* aEvent) { NS_ENSURE_TRUE(!mComposition, NS_OK); if (IsPasswordEditor()) { NS_ENSURE_TRUE(mRules, NS_ERROR_NULL_POINTER); // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); TextEditRules* textEditRules = static_cast<TextEditRules*>(rules.get()); textEditRules->ResetIMETextPWBuf(); } return EditorBase::BeginIMEComposition(aEvent); } nsresult TextEditor::UpdateIMEComposition(nsIDOMEvent* aDOMTextEvent) { MOZ_ASSERT(aDOMTextEvent, "aDOMTextEvent must not be nullptr"); WidgetCompositionEvent* compositionChangeEvent = aDOMTextEvent->WidgetEventPtr()->AsCompositionEvent(); NS_ENSURE_TRUE(compositionChangeEvent, NS_ERROR_INVALID_ARG); MOZ_ASSERT(compositionChangeEvent->mMessage == eCompositionChange, "The internal event should be eCompositionChange"); if (!EnsureComposition(compositionChangeEvent)) { return NS_OK; } nsCOMPtr<nsIPresShell> ps = GetPresShell(); NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED); RefPtr<Selection> selection = GetSelection(); NS_ENSURE_STATE(selection); // NOTE: TextComposition should receive selection change notification before // CompositionChangeEventHandlingMarker notifies TextComposition of the // end of handling compositionchange event because TextComposition may // need to ignore selection changes caused by composition. Therefore, // CompositionChangeEventHandlingMarker must be destroyed after a call // of NotifiyEditorObservers(eNotifyEditorObserversOfEnd) or // NotifiyEditorObservers(eNotifyEditorObserversOfCancel) which notifies // TextComposition of a selection change. MOZ_ASSERT(!mPlaceHolderBatch, "UpdateIMEComposition() must be called without place holder batch"); TextComposition::CompositionChangeEventHandlingMarker compositionChangeEventHandlingMarker(mComposition, compositionChangeEvent); NotifyEditorObservers(eNotifyEditorObserversOfBefore); RefPtr<nsCaret> caretP = ps->GetCaret(); nsresult rv; { AutoPlaceHolderBatch batch(this, nsGkAtoms::IMETxnName); rv = InsertText(compositionChangeEvent->mData); if (caretP) { caretP->SetSelection(selection); } } // If still composing, we should fire input event via observer. // Note that if the composition will be committed by the following // compositionend event, we don't need to notify editor observes of this // change. // NOTE: We must notify after the auto batch will be gone. if (!compositionChangeEvent->IsFollowedByCompositionEnd()) { NotifyEditorObservers(eNotifyEditorObserversOfEnd); } return rv; } already_AddRefed<nsIContent> TextEditor::GetInputEventTargetContent() { nsCOMPtr<nsIContent> target = do_QueryInterface(mEventTarget); return target.forget(); } NS_IMETHODIMP TextEditor::GetDocumentIsEmpty(bool* aDocumentIsEmpty) { NS_ENSURE_TRUE(aDocumentIsEmpty, NS_ERROR_NULL_POINTER); NS_ENSURE_TRUE(mRules, NS_ERROR_NOT_INITIALIZED); // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); return rules->DocumentIsEmpty(aDocumentIsEmpty); } NS_IMETHODIMP TextEditor::GetTextLength(int32_t* aCount) { NS_ASSERTION(aCount, "null pointer"); // initialize out params *aCount = 0; // special-case for empty document, to account for the bogus node bool docEmpty; nsresult rv = GetDocumentIsEmpty(&docEmpty); NS_ENSURE_SUCCESS(rv, rv); if (docEmpty) { return NS_OK; } dom::Element *rootElement = GetRoot(); NS_ENSURE_TRUE(rootElement, NS_ERROR_NULL_POINTER); nsCOMPtr<nsIContentIterator> iter = do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &rv); NS_ENSURE_SUCCESS(rv, rv); uint32_t totalLength = 0; iter->Init(rootElement); for (; !iter->IsDone(); iter->Next()) { nsCOMPtr<nsIDOMNode> currentNode = do_QueryInterface(iter->GetCurrentNode()); nsCOMPtr<nsIDOMCharacterData> textNode = do_QueryInterface(currentNode); if (textNode && IsEditable(currentNode)) { uint32_t length; textNode->GetLength(&length); totalLength += length; } } *aCount = totalLength; return NS_OK; } NS_IMETHODIMP TextEditor::SetMaxTextLength(int32_t aMaxTextLength) { mMaxTextLength = aMaxTextLength; return NS_OK; } NS_IMETHODIMP TextEditor::GetMaxTextLength(int32_t* aMaxTextLength) { NS_ENSURE_TRUE(aMaxTextLength, NS_ERROR_INVALID_POINTER); *aMaxTextLength = mMaxTextLength; return NS_OK; } NS_IMETHODIMP TextEditor::GetWrapWidth(int32_t* aWrapColumn) { NS_ENSURE_TRUE( aWrapColumn, NS_ERROR_NULL_POINTER); *aWrapColumn = mWrapColumn; return NS_OK; } // // See if the style value includes this attribute, and if it does, // cut out everything from the attribute to the next semicolon. // static void CutStyle(const char* stylename, nsString& styleValue) { // Find the current wrapping type: int32_t styleStart = styleValue.Find(stylename, true); if (styleStart >= 0) { int32_t styleEnd = styleValue.Find(";", false, styleStart); if (styleEnd > styleStart) { styleValue.Cut(styleStart, styleEnd - styleStart + 1); } else { styleValue.Cut(styleStart, styleValue.Length() - styleStart); } } } NS_IMETHODIMP TextEditor::SetWrapWidth(int32_t aWrapColumn) { SetWrapColumn(aWrapColumn); // Make sure we're a plaintext editor, otherwise we shouldn't // do the rest of this. if (!IsPlaintextEditor()) { return NS_OK; } // Ought to set a style sheet here ... // Probably should keep around an mPlaintextStyleSheet for this purpose. dom::Element *rootElement = GetRoot(); NS_ENSURE_TRUE(rootElement, NS_ERROR_NULL_POINTER); // Get the current style for this root element: nsAutoString styleValue; rootElement->GetAttr(kNameSpaceID_None, nsGkAtoms::style, styleValue); // We'll replace styles for these values: CutStyle("white-space", styleValue); CutStyle("width", styleValue); CutStyle("font-family", styleValue); // If we have other style left, trim off any existing semicolons // or whitespace, then add a known semicolon-space: if (!styleValue.IsEmpty()) { styleValue.Trim("; \t", false, true); styleValue.AppendLiteral("; "); } // Make sure we have fixed-width font. This should be done for us, // but it isn't, see bug 22502, so we have to add "font: -moz-fixed;". // Only do this if we're wrapping. if (IsWrapHackEnabled() && aWrapColumn >= 0) { styleValue.AppendLiteral("font-family: -moz-fixed; "); } // and now we're ready to set the new whitespace/wrapping style. if (aWrapColumn > 0) { // Wrap to a fixed column. styleValue.AppendLiteral("white-space: pre-wrap; width: "); styleValue.AppendInt(aWrapColumn); styleValue.AppendLiteral("ch;"); } else if (!aWrapColumn) { styleValue.AppendLiteral("white-space: pre-wrap;"); } else { styleValue.AppendLiteral("white-space: pre;"); } return rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::style, styleValue, true); } NS_IMETHODIMP TextEditor::SetWrapColumn(int32_t aWrapColumn) { mWrapColumn = aWrapColumn; return NS_OK; } NS_IMETHODIMP TextEditor::GetNewlineHandling(int32_t* aNewlineHandling) { NS_ENSURE_ARG_POINTER(aNewlineHandling); *aNewlineHandling = mNewlineHandling; return NS_OK; } NS_IMETHODIMP TextEditor::SetNewlineHandling(int32_t aNewlineHandling) { mNewlineHandling = aNewlineHandling; return NS_OK; } NS_IMETHODIMP TextEditor::Undo(uint32_t aCount) { // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); AutoUpdateViewBatch beginViewBatching(this); ForceCompositionEnd(); NotifyEditorObservers(eNotifyEditorObserversOfBefore); AutoRules beginRulesSniffing(this, EditAction::undo, nsIEditor::eNone); TextRulesInfo ruleInfo(EditAction::undo); RefPtr<Selection> selection = GetSelection(); bool cancel, handled; nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled); if (!cancel && NS_SUCCEEDED(rv)) { rv = EditorBase::Undo(aCount); rv = rules->DidDoAction(selection, &ruleInfo, rv); } NotifyEditorObservers(eNotifyEditorObserversOfEnd); return rv; } NS_IMETHODIMP TextEditor::Redo(uint32_t aCount) { // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); AutoUpdateViewBatch beginViewBatching(this); ForceCompositionEnd(); NotifyEditorObservers(eNotifyEditorObserversOfBefore); AutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone); TextRulesInfo ruleInfo(EditAction::redo); RefPtr<Selection> selection = GetSelection(); bool cancel, handled; nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled); if (!cancel && NS_SUCCEEDED(rv)) { rv = EditorBase::Redo(aCount); rv = rules->DidDoAction(selection, &ruleInfo, rv); } NotifyEditorObservers(eNotifyEditorObserversOfEnd); return rv; } bool TextEditor::CanCutOrCopy(PasswordFieldAllowed aPasswordFieldAllowed) { RefPtr<Selection> selection = GetSelection(); if (!selection) { return false; } if (aPasswordFieldAllowed == ePasswordFieldNotAllowed && IsPasswordEditor()) { return false; } return !selection->Collapsed(); } bool TextEditor::FireClipboardEvent(EventMessage aEventMessage, int32_t aSelectionType, bool* aActionTaken) { if (aEventMessage == ePaste) { ForceCompositionEnd(); } nsCOMPtr<nsIPresShell> presShell = GetPresShell(); NS_ENSURE_TRUE(presShell, false); RefPtr<Selection> selection = GetSelection(); if (!selection) { return false; } if (!nsCopySupport::FireClipboardEvent(aEventMessage, aSelectionType, presShell, selection, aActionTaken)) { return false; } // If the event handler caused the editor to be destroyed, return false. // Otherwise return true to indicate that the event was not cancelled. return !mDidPreDestroy; } NS_IMETHODIMP TextEditor::Cut() { bool actionTaken = false; if (FireClipboardEvent(eCut, nsIClipboard::kGlobalClipboard, &actionTaken)) { DeleteSelection(eNone, eStrip); } return actionTaken ? NS_OK : NS_ERROR_FAILURE; } NS_IMETHODIMP TextEditor::CanCut(bool* aCanCut) { NS_ENSURE_ARG_POINTER(aCanCut); // Cut is always enabled in HTML documents nsCOMPtr<nsIDocument> doc = GetDocument(); *aCanCut = (doc && doc->IsHTMLOrXHTML()) || (IsModifiable() && CanCutOrCopy(ePasswordFieldNotAllowed)); return NS_OK; } NS_IMETHODIMP TextEditor::Copy() { bool actionTaken = false; FireClipboardEvent(eCopy, nsIClipboard::kGlobalClipboard, &actionTaken); return actionTaken ? NS_OK : NS_ERROR_FAILURE; } NS_IMETHODIMP TextEditor::CanCopy(bool* aCanCopy) { NS_ENSURE_ARG_POINTER(aCanCopy); // Copy is always enabled in HTML documents nsCOMPtr<nsIDocument> doc = GetDocument(); *aCanCopy = (doc && doc->IsHTMLOrXHTML()) || CanCutOrCopy(ePasswordFieldNotAllowed); return NS_OK; } NS_IMETHODIMP TextEditor::CanDelete(bool* aCanDelete) { NS_ENSURE_ARG_POINTER(aCanDelete); *aCanDelete = IsModifiable() && CanCutOrCopy(ePasswordFieldAllowed); return NS_OK; } // Shared between OutputToString and OutputToStream NS_IMETHODIMP TextEditor::GetAndInitDocEncoder(const nsAString& aFormatType, uint32_t aFlags, const nsACString& aCharset, nsIDocumentEncoder** encoder) { nsresult rv = NS_OK; nsAutoCString formatType(NS_DOC_ENCODER_CONTRACTID_BASE); LossyAppendUTF16toASCII(aFormatType, formatType); nsCOMPtr<nsIDocumentEncoder> docEncoder (do_CreateInstance(formatType.get(), &rv)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIDOMDocument> domDoc = do_QueryReferent(mDocWeak); NS_ASSERTION(domDoc, "Need a document"); rv = docEncoder->Init(domDoc, aFormatType, aFlags); NS_ENSURE_SUCCESS(rv, rv); if (!aCharset.IsEmpty() && !aCharset.EqualsLiteral("null")) { docEncoder->SetCharset(aCharset); } int32_t wc; (void) GetWrapWidth(&wc); if (wc >= 0) { (void) docEncoder->SetWrapColumn(wc); } // Set the selection, if appropriate. // We do this either if the OutputSelectionOnly flag is set, // in which case we use our existing selection ... if (aFlags & nsIDocumentEncoder::OutputSelectionOnly) { RefPtr<Selection> selection = GetSelection(); NS_ENSURE_STATE(selection); rv = docEncoder->SetSelection(selection); NS_ENSURE_SUCCESS(rv, rv); } // ... or if the root element is not a body, // in which case we set the selection to encompass the root. else { dom::Element* rootElement = GetRoot(); NS_ENSURE_TRUE(rootElement, NS_ERROR_FAILURE); if (!rootElement->IsHTMLElement(nsGkAtoms::body)) { rv = docEncoder->SetNativeContainerNode(rootElement); NS_ENSURE_SUCCESS(rv, rv); } } docEncoder.forget(encoder); return NS_OK; } NS_IMETHODIMP TextEditor::OutputToString(const nsAString& aFormatType, uint32_t aFlags, nsAString& aOutputString) { // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); nsString resultString; TextRulesInfo ruleInfo(EditAction::outputText); ruleInfo.outString = &resultString; // XXX Struct should store a nsAReadable* nsAutoString str(aFormatType); ruleInfo.outputFormat = &str; bool cancel, handled; nsresult rv = rules->WillDoAction(nullptr, &ruleInfo, &cancel, &handled); if (cancel || NS_FAILED(rv)) { return rv; } if (handled) { // This case will get triggered by password fields. aOutputString.Assign(*(ruleInfo.outString)); return rv; } nsAutoCString charsetStr; rv = GetDocumentCharacterSet(charsetStr); if (NS_FAILED(rv) || charsetStr.IsEmpty()) { charsetStr.AssignLiteral("ISO-8859-1"); } nsCOMPtr<nsIDocumentEncoder> encoder; rv = GetAndInitDocEncoder(aFormatType, aFlags, charsetStr, getter_AddRefs(encoder)); NS_ENSURE_SUCCESS(rv, rv); return encoder->EncodeToString(aOutputString); } NS_IMETHODIMP TextEditor::OutputToStream(nsIOutputStream* aOutputStream, const nsAString& aFormatType, const nsACString& aCharset, uint32_t aFlags) { nsresult rv; // special-case for empty document when requesting plain text, // to account for the bogus text node. // XXX Should there be a similar test in OutputToString? if (aFormatType.EqualsLiteral("text/plain")) { bool docEmpty; rv = GetDocumentIsEmpty(&docEmpty); NS_ENSURE_SUCCESS(rv, rv); if (docEmpty) { return NS_OK; // Output nothing. } } nsCOMPtr<nsIDocumentEncoder> encoder; rv = GetAndInitDocEncoder(aFormatType, aFlags, aCharset, getter_AddRefs(encoder)); NS_ENSURE_SUCCESS(rv, rv); return encoder->EncodeToStream(aOutputStream); } NS_IMETHODIMP TextEditor::InsertTextWithQuotations(const nsAString& aStringToInsert) { return InsertText(aStringToInsert); } NS_IMETHODIMP TextEditor::PasteAsQuotation(int32_t aSelectionType) { // Get Clipboard Service nsresult rv; nsCOMPtr<nsIClipboard> clipboard(do_GetService("@mozilla.org/widget/clipboard;1", &rv)); NS_ENSURE_SUCCESS(rv, rv); // Get the nsITransferable interface for getting the data from the clipboard nsCOMPtr<nsITransferable> trans; rv = PrepareTransferable(getter_AddRefs(trans)); if (NS_SUCCEEDED(rv) && trans) { // Get the Data from the clipboard clipboard->GetData(trans, aSelectionType); // Now we ask the transferable for the data // it still owns the data, we just have a pointer to it. // If it can't support a "text" output of the data the call will fail nsCOMPtr<nsISupports> genericDataObj; uint32_t len; nsAutoCString flav; rv = trans->GetAnyTransferData(flav, getter_AddRefs(genericDataObj), &len); if (NS_FAILED(rv)) { return rv; } if (flav.EqualsLiteral(kUnicodeMime) || flav.EqualsLiteral(kMozTextInternal)) { nsCOMPtr<nsISupportsString> textDataObj ( do_QueryInterface(genericDataObj) ); if (textDataObj && len > 0) { nsAutoString stuffToPaste; textDataObj->GetData ( stuffToPaste ); AutoEditBatch beginBatching(this); rv = InsertAsQuotation(stuffToPaste, 0); } } } return rv; } NS_IMETHODIMP TextEditor::InsertAsQuotation(const nsAString& aQuotedText, nsIDOMNode** aNodeInserted) { // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); // Let the citer quote it for us: nsString quotedStuff; nsresult rv = InternetCiter::GetCiteString(aQuotedText, quotedStuff); NS_ENSURE_SUCCESS(rv, rv); // It's best to put a blank line after the quoted text so that mails // written without thinking won't be so ugly. if (!aQuotedText.IsEmpty() && (aQuotedText.Last() != char16_t('\n'))) { quotedStuff.Append(char16_t('\n')); } // get selection RefPtr<Selection> selection = GetSelection(); NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER); AutoEditBatch beginBatching(this); AutoRules beginRulesSniffing(this, EditAction::insertText, nsIEditor::eNext); // give rules a chance to handle or cancel TextRulesInfo ruleInfo(EditAction::insertElement); bool cancel, handled; rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled); NS_ENSURE_SUCCESS(rv, rv); if (cancel) { return NS_OK; // Rules canceled the operation. } if (!handled) { rv = InsertText(quotedStuff); // XXX Should set *aNodeInserted to the first node inserted if (aNodeInserted && NS_SUCCEEDED(rv)) { *aNodeInserted = nullptr; } } return rv; } NS_IMETHODIMP TextEditor::PasteAsCitedQuotation(const nsAString& aCitation, int32_t aSelectionType) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP TextEditor::InsertAsCitedQuotation(const nsAString& aQuotedText, const nsAString& aCitation, bool aInsertHTML, nsIDOMNode** aNodeInserted) { return InsertAsQuotation(aQuotedText, aNodeInserted); } nsresult TextEditor::SharedOutputString(uint32_t aFlags, bool* aIsCollapsed, nsAString& aResult) { RefPtr<Selection> selection = GetSelection(); NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED); *aIsCollapsed = selection->Collapsed(); if (!*aIsCollapsed) { aFlags |= nsIDocumentEncoder::OutputSelectionOnly; } // If the selection isn't collapsed, we'll use the whole document. return OutputToString(NS_LITERAL_STRING("text/plain"), aFlags, aResult); } NS_IMETHODIMP TextEditor::Rewrap(bool aRespectNewlines) { int32_t wrapCol; nsresult rv = GetWrapWidth(&wrapCol); NS_ENSURE_SUCCESS(rv, NS_OK); // Rewrap makes no sense if there's no wrap column; default to 72. if (wrapCol <= 0) { wrapCol = 72; } nsAutoString current; bool isCollapsed; rv = SharedOutputString(nsIDocumentEncoder::OutputFormatted | nsIDocumentEncoder::OutputLFLineBreak, &isCollapsed, current); NS_ENSURE_SUCCESS(rv, rv); nsString wrapped; uint32_t firstLineOffset = 0; // XXX need to reset this if there is a selection rv = InternetCiter::Rewrap(current, wrapCol, firstLineOffset, aRespectNewlines, wrapped); NS_ENSURE_SUCCESS(rv, rv); if (isCollapsed) { SelectAll(); } return InsertTextWithQuotations(wrapped); } NS_IMETHODIMP TextEditor::StripCites() { nsAutoString current; bool isCollapsed; nsresult rv = SharedOutputString(nsIDocumentEncoder::OutputFormatted, &isCollapsed, current); NS_ENSURE_SUCCESS(rv, rv); nsString stripped; rv = InternetCiter::StripCites(current, stripped); NS_ENSURE_SUCCESS(rv, rv); if (isCollapsed) { rv = SelectAll(); NS_ENSURE_SUCCESS(rv, rv); } return InsertText(stripped); } NS_IMETHODIMP TextEditor::GetEmbeddedObjects(nsIArray** aNodeList) { if (NS_WARN_IF(!aNodeList)) { return NS_ERROR_INVALID_ARG; } *aNodeList = nullptr; return NS_OK; } /** * All editor operations which alter the doc should be prefaced * with a call to StartOperation, naming the action and direction. */ NS_IMETHODIMP TextEditor::StartOperation(EditAction opID, nsIEditor::EDirection aDirection) { // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); EditorBase::StartOperation(opID, aDirection); // will set mAction, mDirection if (rules) { return rules->BeforeEdit(mAction, mDirection); } return NS_OK; } /** * All editor operations which alter the doc should be followed * with a call to EndOperation. */ NS_IMETHODIMP TextEditor::EndOperation() { // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); // post processing nsresult rv = rules ? rules->AfterEdit(mAction, mDirection) : NS_OK; EditorBase::EndOperation(); // will clear mAction, mDirection return rv; } nsresult TextEditor::SelectEntireDocument(Selection* aSelection) { if (!aSelection || !mRules) { return NS_ERROR_NULL_POINTER; } // Protect the edit rules object from dying nsCOMPtr<nsIEditRules> rules(mRules); // is doc empty? bool bDocIsEmpty; if (NS_SUCCEEDED(rules->DocumentIsEmpty(&bDocIsEmpty)) && bDocIsEmpty) { // get root node nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(GetRoot()); NS_ENSURE_TRUE(rootElement, NS_ERROR_FAILURE); // if it's empty don't select entire doc - that would select the bogus node return aSelection->Collapse(rootElement, 0); } SelectionBatcher selectionBatcher(aSelection); nsresult rv = EditorBase::SelectEntireDocument(aSelection); NS_ENSURE_SUCCESS(rv, rv); // Don't select the trailing BR node if we have one int32_t selOffset; nsCOMPtr<nsIDOMNode> selNode; rv = GetEndNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIDOMNode> childNode = GetChildAt(selNode, selOffset - 1); if (childNode && TextEditUtils::IsMozBR(childNode)) { int32_t parentOffset; nsCOMPtr<nsIDOMNode> parentNode = GetNodeLocation(childNode, &parentOffset); return aSelection->Extend(parentNode, parentOffset); } return NS_OK; } already_AddRefed<EventTarget> TextEditor::GetDOMEventTarget() { nsCOMPtr<EventTarget> copy = mEventTarget; return copy.forget(); } nsresult TextEditor::SetAttributeOrEquivalent(nsIDOMElement* aElement, const nsAString& aAttribute, const nsAString& aValue, bool aSuppressTransaction) { return EditorBase::SetAttribute(aElement, aAttribute, aValue); } nsresult TextEditor::RemoveAttributeOrEquivalent(nsIDOMElement* aElement, const nsAString& aAttribute, bool aSuppressTransaction) { return EditorBase::RemoveAttribute(aElement, aAttribute); } } // namespace mozilla