/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* 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 "nsTextEditorState.h" #include "nsCOMPtr.h" #include "nsIPresShell.h" #include "nsView.h" #include "nsCaret.h" #include "nsEditorCID.h" #include "nsLayoutCID.h" #include "nsITextControlFrame.h" #include "nsIPlaintextEditor.h" #include "nsIDOMCharacterData.h" #include "nsIDOMDocument.h" #include "nsContentCreatorFunctions.h" #include "nsTextControlFrame.h" #include "nsIControllers.h" #include "nsIDOMHTMLInputElement.h" #include "nsIDOMHTMLTextAreaElement.h" #include "nsITransactionManager.h" #include "nsIControllerContext.h" #include "nsAttrValue.h" #include "nsAttrValueInlines.h" #include "nsGenericHTMLElement.h" #include "nsIDOMEventListener.h" #include "nsIEditorObserver.h" #include "nsIWidget.h" #include "nsIDocumentEncoder.h" #include "nsISelectionPrivate.h" #include "nsPIDOMWindow.h" #include "nsServiceManagerUtils.h" #include "nsIEditor.h" #include "mozilla/dom/Selection.h" #include "mozilla/TextEditRules.h" #include "mozilla/EventListenerManager.h" #include "nsContentUtils.h" #include "mozilla/Preferences.h" #include "nsTextNode.h" #include "nsIController.h" #include "mozilla/TextEvents.h" #include "mozilla/dom/ScriptSettings.h" #include "mozilla/dom/HTMLInputElement.h" #include "nsNumberControlFrame.h" #include "nsFrameSelection.h" #include "mozilla/ErrorResult.h" #include "mozilla/Telemetry.h" #include "mozilla/layers/ScrollInputMethods.h" using namespace mozilla; using namespace mozilla::dom; using mozilla::layers::ScrollInputMethod; static NS_DEFINE_CID(kTextEditorCID, NS_TEXTEDITOR_CID); class MOZ_STACK_CLASS ValueSetter { public: explicit ValueSetter(nsIEditor* aEditor) : mEditor(aEditor) { MOZ_ASSERT(aEditor); // To protect against a reentrant call to SetValue, we check whether // another SetValue is already happening for this editor. If it is, // we must wait until we unwind to re-enable oninput events. mEditor->GetSuppressDispatchingInputEvent(&mOuterTransaction); } ~ValueSetter() { mEditor->SetSuppressDispatchingInputEvent(mOuterTransaction); } void Init() { mEditor->SetSuppressDispatchingInputEvent(true); } private: nsCOMPtr mEditor; bool mOuterTransaction; }; class RestoreSelectionState : public Runnable { public: RestoreSelectionState(nsTextEditorState *aState, nsTextControlFrame *aFrame) : mFrame(aFrame), mTextEditorState(aState) { } NS_IMETHOD Run() override { if (!mTextEditorState) { return NS_OK; } AutoHideSelectionChanges hideSelectionChanges (mFrame->GetConstFrameSelection()); if (mFrame) { // SetSelectionRange leads to Selection::AddRange which flushes Layout - // need to block script to avoid nested PrepareEditor calls (bug 642800). nsAutoScriptBlocker scriptBlocker; nsTextEditorState::SelectionProperties& properties = mTextEditorState->GetSelectionProperties(); if (properties.IsDirty()) { mFrame->SetSelectionRange(properties.GetStart(), properties.GetEnd(), properties.GetDirection()); } if (!mTextEditorState->mSelectionRestoreEagerInit) { mTextEditorState->HideSelectionIfBlurred(); } mTextEditorState->mSelectionRestoreEagerInit = false; } if (mTextEditorState) { mTextEditorState->FinishedRestoringSelection(); } return NS_OK; } // Let the text editor tell us we're no longer relevant - avoids use of AutoWeakFrame void Revoke() { mFrame = nullptr; mTextEditorState = nullptr; } private: nsTextControlFrame* mFrame; nsTextEditorState* mTextEditorState; }; /*static*/ bool nsITextControlElement::GetWrapPropertyEnum(nsIContent* aContent, nsITextControlElement::nsHTMLTextWrap& aWrapProp) { // soft is the default; "physical" defaults to soft as well because all other // browsers treat it that way and there is no real reason to maintain physical // and virtual as separate entities if no one else does. Only hard and off // do anything different. aWrapProp = eHTMLTextWrap_Soft; // the default nsAutoString wrap; if (aContent->IsHTMLElement()) { static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::HARD, &nsGkAtoms::OFF, nullptr}; switch (aContent->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::wrap, strings, eIgnoreCase)) { case 0: aWrapProp = eHTMLTextWrap_Hard; break; case 1: aWrapProp = eHTMLTextWrap_Off; break; } return true; } return false; } /*static*/ already_AddRefed nsITextControlElement::GetTextControlElementFromEditingHost(nsIContent* aHost) { if (!aHost) { return nullptr; } nsCOMPtr parent = do_QueryInterface(aHost->GetParent()); return parent.forget(); } static bool SuppressEventHandlers(nsPresContext* aPresContext) { bool suppressHandlers = false; if (aPresContext) { // Right now we only suppress event handlers and controller manipulation // when in a print preview or print context! // In the current implementation, we only paginate when // printing or in print preview. suppressHandlers = aPresContext->IsPaginated(); } return suppressHandlers; } class nsAnonDivObserver final : public nsStubMutationObserver { public: explicit nsAnonDivObserver(nsTextEditorState* aTextEditorState) : mTextEditorState(aTextEditorState) {} NS_DECL_ISUPPORTS NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED private: ~nsAnonDivObserver() {} nsTextEditorState* mTextEditorState; }; class nsTextInputSelectionImpl final : public nsSupportsWeakReference , public nsISelectionController { ~nsTextInputSelectionImpl(){} public: NS_DECL_CYCLE_COLLECTING_ISUPPORTS NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsTextInputSelectionImpl, nsISelectionController) nsTextInputSelectionImpl(nsFrameSelection *aSel, nsIPresShell *aShell, nsIContent *aLimiter); void SetScrollableFrame(nsIScrollableFrame *aScrollableFrame); nsFrameSelection* GetConstFrameSelection() { return mFrameSelection; } //NSISELECTIONCONTROLLER INTERFACES NS_IMETHOD SetDisplaySelection(int16_t toggle) override; NS_IMETHOD GetDisplaySelection(int16_t* _retval) override; NS_IMETHOD SetSelectionFlags(int16_t aInEnable) override; NS_IMETHOD GetSelectionFlags(int16_t *aOutEnable) override; NS_IMETHOD GetSelection(RawSelectionType aRawSelectionType, nsISelection** aSelection) override; NS_IMETHOD ScrollSelectionIntoView(RawSelectionType aRawSelectionType, int16_t aRegion, int16_t aFlags) override; NS_IMETHOD RepaintSelection(RawSelectionType aRawSelectionType) override; nsresult RepaintSelection(nsPresContext* aPresContext, SelectionType aSelectionType); NS_IMETHOD SetCaretEnabled(bool enabled) override; NS_IMETHOD SetCaretReadOnly(bool aReadOnly) override; NS_IMETHOD GetCaretEnabled(bool* _retval) override; NS_IMETHOD GetCaretVisible(bool* _retval) override; NS_IMETHOD SetCaretVisibilityDuringSelection(bool aVisibility) override; NS_IMETHOD PhysicalMove(int16_t aDirection, int16_t aAmount, bool aExtend) override; NS_IMETHOD CharacterMove(bool aForward, bool aExtend) override; NS_IMETHOD CharacterExtendForDelete() override; NS_IMETHOD CharacterExtendForBackspace() override; NS_IMETHOD WordMove(bool aForward, bool aExtend) override; NS_IMETHOD WordExtendForDelete(bool aForward) override; NS_IMETHOD LineMove(bool aForward, bool aExtend) override; NS_IMETHOD IntraLineMove(bool aForward, bool aExtend) override; NS_IMETHOD PageMove(bool aForward, bool aExtend) override; NS_IMETHOD CompleteScroll(bool aForward) override; NS_IMETHOD CompleteMove(bool aForward, bool aExtend) override; NS_IMETHOD ScrollPage(bool aForward) override; NS_IMETHOD ScrollLine(bool aForward) override; NS_IMETHOD ScrollCharacter(bool aRight) override; NS_IMETHOD SelectAll(void) override; NS_IMETHOD CheckVisibility(nsIDOMNode *node, int16_t startOffset, int16_t EndOffset, bool* _retval) override; virtual nsresult CheckVisibilityContent(nsIContent* aNode, int16_t aStartOffset, int16_t aEndOffset, bool* aRetval) override; private: RefPtr mFrameSelection; nsCOMPtr mLimiter; nsIScrollableFrame *mScrollFrame; nsWeakPtr mPresShellWeak; }; NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTextInputSelectionImpl) NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTextInputSelectionImpl) NS_INTERFACE_TABLE_HEAD(nsTextInputSelectionImpl) NS_INTERFACE_TABLE(nsTextInputSelectionImpl, nsISelectionController, nsISelectionDisplay, nsISupportsWeakReference) NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(nsTextInputSelectionImpl) NS_INTERFACE_MAP_END NS_IMPL_CYCLE_COLLECTION(nsTextInputSelectionImpl, mFrameSelection, mLimiter) // BEGIN nsTextInputSelectionImpl nsTextInputSelectionImpl::nsTextInputSelectionImpl(nsFrameSelection *aSel, nsIPresShell *aShell, nsIContent *aLimiter) : mScrollFrame(nullptr) { if (aSel && aShell) { mFrameSelection = aSel;//we are the owner now! mLimiter = aLimiter; mFrameSelection->Init(aShell, mLimiter); mPresShellWeak = do_GetWeakReference(aShell); } } void nsTextInputSelectionImpl::SetScrollableFrame(nsIScrollableFrame *aScrollableFrame) { mScrollFrame = aScrollableFrame; if (!mScrollFrame && mFrameSelection) { mFrameSelection->DisconnectFromPresShell(); mFrameSelection = nullptr; } } NS_IMETHODIMP nsTextInputSelectionImpl::SetDisplaySelection(int16_t aToggle) { if (!mFrameSelection) return NS_ERROR_NULL_POINTER; mFrameSelection->SetDisplaySelection(aToggle); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::GetDisplaySelection(int16_t *aToggle) { if (!mFrameSelection) return NS_ERROR_NULL_POINTER; *aToggle = mFrameSelection->GetDisplaySelection(); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::SetSelectionFlags(int16_t aToggle) { return NS_OK;//stub this out. not used in input } NS_IMETHODIMP nsTextInputSelectionImpl::GetSelectionFlags(int16_t *aOutEnable) { *aOutEnable = nsISelectionDisplay::DISPLAY_TEXT; return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::GetSelection(RawSelectionType aRawSelectionType, nsISelection** aSelection) { if (!mFrameSelection) return NS_ERROR_NULL_POINTER; *aSelection = mFrameSelection->GetSelection(ToSelectionType(aRawSelectionType)); // GetSelection() fails only when aRawSelectionType is invalid value. if (!(*aSelection)) { return NS_ERROR_INVALID_ARG; } NS_ADDREF(*aSelection); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::ScrollSelectionIntoView( RawSelectionType aRawSelectionType, int16_t aRegion, int16_t aFlags) { if (!mFrameSelection) return NS_ERROR_FAILURE; return mFrameSelection->ScrollSelectionIntoView( ToSelectionType(aRawSelectionType), aRegion, aFlags); } NS_IMETHODIMP nsTextInputSelectionImpl::RepaintSelection(RawSelectionType aRawSelectionType) { if (!mFrameSelection) return NS_ERROR_FAILURE; return mFrameSelection->RepaintSelection(ToSelectionType(aRawSelectionType)); } nsresult nsTextInputSelectionImpl::RepaintSelection(nsPresContext* aPresContext, SelectionType aSelectionType) { if (!mFrameSelection) return NS_ERROR_FAILURE; return mFrameSelection->RepaintSelection(aSelectionType); } NS_IMETHODIMP nsTextInputSelectionImpl::SetCaretEnabled(bool enabled) { if (!mPresShellWeak) return NS_ERROR_NOT_INITIALIZED; nsCOMPtr shell = do_QueryReferent(mPresShellWeak); if (!shell) return NS_ERROR_FAILURE; // tell the pres shell to enable the caret, rather than settings its visibility directly. // this way the presShell's idea of caret visibility is maintained. nsCOMPtr selCon = do_QueryInterface(shell); if (!selCon) return NS_ERROR_NO_INTERFACE; selCon->SetCaretEnabled(enabled); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::SetCaretReadOnly(bool aReadOnly) { if (!mPresShellWeak) return NS_ERROR_NOT_INITIALIZED; nsresult result; nsCOMPtr shell = do_QueryReferent(mPresShellWeak, &result); if (shell) { RefPtr caret = shell->GetCaret(); if (caret) { nsISelection* domSel = mFrameSelection->GetSelection(SelectionType::eNormal); if (domSel) caret->SetCaretReadOnly(aReadOnly); return NS_OK; } } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsTextInputSelectionImpl::GetCaretEnabled(bool *_retval) { return GetCaretVisible(_retval); } NS_IMETHODIMP nsTextInputSelectionImpl::GetCaretVisible(bool *_retval) { if (!mPresShellWeak) return NS_ERROR_NOT_INITIALIZED; nsresult result; nsCOMPtr shell = do_QueryReferent(mPresShellWeak, &result); if (shell) { RefPtr caret = shell->GetCaret(); if (caret) { *_retval = caret->IsVisible(); return NS_OK; } } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsTextInputSelectionImpl::SetCaretVisibilityDuringSelection(bool aVisibility) { if (!mPresShellWeak) return NS_ERROR_NOT_INITIALIZED; nsresult result; nsCOMPtr shell = do_QueryReferent(mPresShellWeak, &result); if (shell) { RefPtr caret = shell->GetCaret(); if (caret) { nsISelection* domSel = mFrameSelection->GetSelection(SelectionType::eNormal); if (domSel) caret->SetVisibilityDuringSelection(aVisibility); return NS_OK; } } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsTextInputSelectionImpl::PhysicalMove(int16_t aDirection, int16_t aAmount, bool aExtend) { if (mFrameSelection) return mFrameSelection->PhysicalMove(aDirection, aAmount, aExtend); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::CharacterMove(bool aForward, bool aExtend) { if (mFrameSelection) return mFrameSelection->CharacterMove(aForward, aExtend); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::CharacterExtendForDelete() { if (mFrameSelection) return mFrameSelection->CharacterExtendForDelete(); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::CharacterExtendForBackspace() { if (mFrameSelection) return mFrameSelection->CharacterExtendForBackspace(); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::WordMove(bool aForward, bool aExtend) { if (mFrameSelection) return mFrameSelection->WordMove(aForward, aExtend); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::WordExtendForDelete(bool aForward) { if (mFrameSelection) return mFrameSelection->WordExtendForDelete(aForward); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::LineMove(bool aForward, bool aExtend) { if (mFrameSelection) { nsresult result = mFrameSelection->LineMove(aForward, aExtend); if (NS_FAILED(result)) result = CompleteMove(aForward,aExtend); return result; } return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::IntraLineMove(bool aForward, bool aExtend) { if (mFrameSelection) return mFrameSelection->IntraLineMove(aForward, aExtend); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::PageMove(bool aForward, bool aExtend) { // expected behavior for PageMove is to scroll AND move the caret // and to remain relative position of the caret in view. see Bug 4302. if (mScrollFrame) { mFrameSelection->CommonPageMove(aForward, aExtend, mScrollFrame); } // After ScrollSelectionIntoView(), the pending notifications might be // flushed and PresShell/PresContext/Frames may be dead. See bug 418470. return ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL, nsISelectionController::SELECTION_FOCUS_REGION, nsISelectionController::SCROLL_SYNCHRONOUS | nsISelectionController::SCROLL_FOR_CARET_MOVE); } NS_IMETHODIMP nsTextInputSelectionImpl::CompleteScroll(bool aForward) { if (!mScrollFrame) return NS_ERROR_NOT_INITIALIZED; mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, (uint32_t) ScrollInputMethod::MainThreadCompleteScroll); mScrollFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1), nsIScrollableFrame::WHOLE, nsIScrollableFrame::INSTANT); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::CompleteMove(bool aForward, bool aExtend) { // grab the parent / root DIV for this text widget nsIContent* parentDIV = mFrameSelection->GetLimiter(); if (!parentDIV) return NS_ERROR_UNEXPECTED; // make the caret be either at the very beginning (0) or the very end int32_t offset = 0; CaretAssociationHint hint = CARET_ASSOCIATE_BEFORE; if (aForward) { offset = parentDIV->GetChildCount(); // Prevent the caret from being placed after the last // BR node in the content tree! if (offset > 0) { nsIContent *child = parentDIV->GetLastChild(); if (child->IsHTMLElement(nsGkAtoms::br)) { --offset; hint = CARET_ASSOCIATE_AFTER; // for Bug 106855 } } } mFrameSelection->HandleClick(parentDIV, offset, offset, aExtend, false, hint); // if we got this far, attempt to scroll no matter what the above result is return CompleteScroll(aForward); } NS_IMETHODIMP nsTextInputSelectionImpl::ScrollPage(bool aForward) { if (!mScrollFrame) return NS_ERROR_NOT_INITIALIZED; mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, (uint32_t) ScrollInputMethod::MainThreadScrollPage); mScrollFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1), nsIScrollableFrame::PAGES, nsIScrollableFrame::SMOOTH); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::ScrollLine(bool aForward) { if (!mScrollFrame) return NS_ERROR_NOT_INITIALIZED; mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, (uint32_t) ScrollInputMethod::MainThreadScrollLine); mScrollFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1), nsIScrollableFrame::LINES, nsIScrollableFrame::SMOOTH); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::ScrollCharacter(bool aRight) { if (!mScrollFrame) return NS_ERROR_NOT_INITIALIZED; mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, (uint32_t) ScrollInputMethod::MainThreadScrollCharacter); mScrollFrame->ScrollBy(nsIntPoint(aRight ? 1 : -1, 0), nsIScrollableFrame::LINES, nsIScrollableFrame::SMOOTH); return NS_OK; } NS_IMETHODIMP nsTextInputSelectionImpl::SelectAll() { if (mFrameSelection) return mFrameSelection->SelectAll(); return NS_ERROR_NULL_POINTER; } NS_IMETHODIMP nsTextInputSelectionImpl::CheckVisibility(nsIDOMNode *node, int16_t startOffset, int16_t EndOffset, bool *_retval) { if (!mPresShellWeak) return NS_ERROR_NOT_INITIALIZED; nsresult result; nsCOMPtr shell = do_QueryReferent(mPresShellWeak, &result); if (shell) { return shell->CheckVisibility(node,startOffset,EndOffset, _retval); } return NS_ERROR_FAILURE; } nsresult nsTextInputSelectionImpl::CheckVisibilityContent(nsIContent* aNode, int16_t aStartOffset, int16_t aEndOffset, bool* aRetval) { if (!mPresShellWeak) { return NS_ERROR_NOT_INITIALIZED; } nsCOMPtr shell = do_QueryReferent(mPresShellWeak); NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE); return shell->CheckVisibilityContent(aNode, aStartOffset, aEndOffset, aRetval); } class nsTextInputListener : public nsISelectionListener, public nsIDOMEventListener, public nsIEditorObserver, public nsSupportsWeakReference { public: /** the default constructor */ explicit nsTextInputListener(nsITextControlElement* aTxtCtrlElement); /** SetEditor gives an address to the editor that will be accessed * @param aEditor the editor this listener calls for editing operations */ void SetFrame(nsTextControlFrame *aFrame){mFrame = aFrame;} void SettingValue(bool aValue) { mSettingValue = aValue; } void SetValueChanged(bool aSetValueChanged) { mSetValueChanged = aSetValueChanged; } NS_DECL_ISUPPORTS NS_DECL_NSISELECTIONLISTENER NS_DECL_NSIDOMEVENTLISTENER NS_DECL_NSIEDITOROBSERVER protected: /** the default destructor. virtual due to the possibility of derivation. */ virtual ~nsTextInputListener(); nsresult UpdateTextInputCommands(const nsAString& commandsToUpdate, nsISelection* sel = nullptr, int16_t reason = 0); protected: nsIFrame* mFrame; nsITextControlElement* const mTxtCtrlElement; bool mSelectionWasCollapsed; /** * Whether we had undo items or not the last time we got EditAction() * notification (when this state changes we update undo and redo menus) */ bool mHadUndoItems; /** * Whether we had redo items or not the last time we got EditAction() * notification (when this state changes we update undo and redo menus) */ bool mHadRedoItems; /** * Whether we're in the process of a SetValue call, and should therefore * refrain from calling OnValueChanged. */ bool mSettingValue; /** * Whether we are in the process of a SetValue call that doesn't want * |SetValueChanged| to be called. */ bool mSetValueChanged; }; /* * nsTextInputListener implementation */ nsTextInputListener::nsTextInputListener(nsITextControlElement* aTxtCtrlElement) : mFrame(nullptr) , mTxtCtrlElement(aTxtCtrlElement) , mSelectionWasCollapsed(true) , mHadUndoItems(false) , mHadRedoItems(false) , mSettingValue(false) , mSetValueChanged(true) { } nsTextInputListener::~nsTextInputListener() { } NS_IMPL_ISUPPORTS(nsTextInputListener, nsISelectionListener, nsIEditorObserver, nsISupportsWeakReference, nsIDOMEventListener) // BEGIN nsIDOMSelectionListener NS_IMETHODIMP nsTextInputListener::NotifySelectionChanged(nsIDOMDocument* aDoc, nsISelection* aSel, int16_t aReason) { bool collapsed; AutoWeakFrame weakFrame = mFrame; if (!aDoc || !aSel || NS_FAILED(aSel->GetIsCollapsed(&collapsed))) return NS_OK; // Fire the select event // The specs don't exactly say when we should fire the select event. // IE: Whenever you add/remove a character to/from the selection. Also // each time for select all. Also if you get to the end of the text // field you will get new event for each keypress or a continuous // stream of events if you use the mouse. IE will fire select event // when the selection collapses to nothing if you are holding down // the shift or mouse button. // Mozilla: If we have non-empty selection we will fire a new event for each // keypress (or mouseup) if the selection changed. Mozilla will also // create the event each time select all is called, even if everything // was previously selected, becase technically select all will first collapse // and then extend. Mozilla will never create an event if the selection // collapses to nothing. if (!collapsed && (aReason & (nsISelectionListener::MOUSEUP_REASON | nsISelectionListener::KEYPRESS_REASON | nsISelectionListener::SELECTALL_REASON))) { nsIContent* content = mFrame->GetContent(); if (content) { nsCOMPtr doc = content->GetComposedDoc(); if (doc) { nsCOMPtr presShell = doc->GetShell(); if (presShell) { nsEventStatus status = nsEventStatus_eIgnore; WidgetEvent event(true, eFormSelect); presShell->HandleEventWithTarget(&event, mFrame, content, &status); } } } } // if the collapsed state did not change, don't fire notifications if (collapsed == mSelectionWasCollapsed) return NS_OK; mSelectionWasCollapsed = collapsed; if (!weakFrame.IsAlive() || !nsContentUtils::IsFocusedContent(mFrame->GetContent())) return NS_OK; return UpdateTextInputCommands(NS_LITERAL_STRING("select"), aSel, aReason); } // END nsIDOMSelectionListener static void DoCommandCallback(Command aCommand, void* aData) { nsTextControlFrame *frame = static_cast(aData); nsIContent *content = frame->GetContent(); nsCOMPtr controllers; nsCOMPtr input = do_QueryInterface(content); if (input) { input->GetControllers(getter_AddRefs(controllers)); } else { nsCOMPtr textArea = do_QueryInterface(content); if (textArea) { textArea->GetControllers(getter_AddRefs(controllers)); } } if (!controllers) { NS_WARNING("Could not get controllers"); return; } const char* commandStr = WidgetKeyboardEvent::GetCommandStr(aCommand); nsCOMPtr controller; controllers->GetControllerForCommand(commandStr, getter_AddRefs(controller)); if (!controller) { return; } bool commandEnabled; nsresult rv = controller->IsCommandEnabled(commandStr, &commandEnabled); NS_ENSURE_SUCCESS_VOID(rv); if (commandEnabled) { controller->DoCommand(commandStr); } } NS_IMETHODIMP nsTextInputListener::HandleEvent(nsIDOMEvent* aEvent) { bool defaultPrevented = false; nsresult rv = aEvent->GetDefaultPrevented(&defaultPrevented); NS_ENSURE_SUCCESS(rv, rv); if (defaultPrevented) { return NS_OK; } bool isTrusted = false; rv = aEvent->GetIsTrusted(&isTrusted); NS_ENSURE_SUCCESS(rv, rv); if (!isTrusted) { return NS_OK; } WidgetKeyboardEvent* keyEvent = aEvent->WidgetEventPtr()->AsKeyboardEvent(); if (!keyEvent) { return NS_ERROR_UNEXPECTED; } if (keyEvent->mMessage != eKeyPress) { return NS_OK; } nsIWidget::NativeKeyBindingsType nativeKeyBindingsType = mTxtCtrlElement->IsTextArea() ? nsIWidget::NativeKeyBindingsForMultiLineEditor : nsIWidget::NativeKeyBindingsForSingleLineEditor; nsIWidget* widget = keyEvent->mWidget; // If the event is created by chrome script, the widget is nullptr. if (!widget) { widget = mFrame->GetNearestWidget(); NS_ENSURE_TRUE(widget, NS_OK); } if (widget->ExecuteNativeKeyBinding(nativeKeyBindingsType, *keyEvent, DoCommandCallback, mFrame)) { aEvent->PreventDefault(); } return NS_OK; } // BEGIN nsIEditorObserver NS_IMETHODIMP nsTextInputListener::EditAction() { if (!mFrame) { // We've been disconnected from the nsTextEditorState object, nothing to do // here. return NS_OK; } AutoWeakFrame weakFrame = mFrame; nsITextControlFrame* frameBase = do_QueryFrame(mFrame); nsTextControlFrame* frame = static_cast (frameBase); NS_ASSERTION(frame, "Where is our frame?"); // // Update the undo / redo menus // nsCOMPtr editor; frame->GetEditor(getter_AddRefs(editor)); // Get the number of undo / redo items int32_t numUndoItems = 0; int32_t numRedoItems = 0; editor->GetNumberOfUndoItems(&numUndoItems); editor->GetNumberOfRedoItems(&numRedoItems); if ((numUndoItems && !mHadUndoItems) || (!numUndoItems && mHadUndoItems) || (numRedoItems && !mHadRedoItems) || (!numRedoItems && mHadRedoItems)) { // Modify the menu if undo or redo items are different UpdateTextInputCommands(NS_LITERAL_STRING("undo")); mHadUndoItems = numUndoItems != 0; mHadRedoItems = numRedoItems != 0; } if (!weakFrame.IsAlive()) { return NS_OK; } // Make sure we know we were changed (do NOT set this to false if there are // no undo items; JS could change the value and we'd still need to save it) if (mSetValueChanged) { frame->SetValueChanged(true); } if (!mSettingValue) { mTxtCtrlElement->OnValueChanged(/* aNotify = */ true, /* aWasInteractiveUserChange = */ true); } return NS_OK; } NS_IMETHODIMP nsTextInputListener::BeforeEditAction() { return NS_OK; } NS_IMETHODIMP nsTextInputListener::CancelEditAction() { return NS_OK; } // END nsIEditorObserver nsresult nsTextInputListener::UpdateTextInputCommands(const nsAString& commandsToUpdate, nsISelection* sel, int16_t reason) { nsIContent* content = mFrame->GetContent(); NS_ENSURE_TRUE(content, NS_ERROR_FAILURE); nsCOMPtr doc = content->GetComposedDoc(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); nsPIDOMWindowOuter *domWindow = doc->GetWindow(); NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE); return domWindow->UpdateCommands(commandsToUpdate, sel, reason); } // END nsTextInputListener // nsTextEditorState nsTextEditorState::nsTextEditorState(nsITextControlElement* aOwningElement) : mTextCtrlElement(aOwningElement) , mBoundFrame(nullptr) , mEverInited(false) , mEditorInitialized(false) , mInitializing(false) , mValueTransferInProgress(false) , mSelectionCached(true) , mSelectionRestoreEagerInit(false) , mPlaceholderVisibility(false) , mIsCommittingComposition(false) { MOZ_COUNT_CTOR(nsTextEditorState); } nsTextEditorState::~nsTextEditorState() { MOZ_COUNT_DTOR(nsTextEditorState); Clear(); } void nsTextEditorState::Clear() { if (mBoundFrame) { // Oops, we still have a frame! // This should happen when the type of a text input control is being changed // to something which is not a text control. In this case, we should pretend // that a frame is being destroyed, and clean up after ourselves properly. UnbindFromFrame(mBoundFrame); mEditor = nullptr; } else { // If we have a bound frame around, UnbindFromFrame will call DestroyEditor // for us. DestroyEditor(); } mTextListener = nullptr; } void nsTextEditorState::Unlink() { nsTextEditorState* tmp = this; tmp->Clear(); NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelCon) NS_IMPL_CYCLE_COLLECTION_UNLINK(mEditor) NS_IMPL_CYCLE_COLLECTION_UNLINK(mRootNode) NS_IMPL_CYCLE_COLLECTION_UNLINK(mPlaceholderDiv) } void nsTextEditorState::Traverse(nsCycleCollectionTraversalCallback& cb) { nsTextEditorState* tmp = this; NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelCon) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditor) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootNode) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPlaceholderDiv) } nsFrameSelection* nsTextEditorState::GetConstFrameSelection() { if (mSelCon) return mSelCon->GetConstFrameSelection(); return nullptr; } nsIEditor* nsTextEditorState::GetEditor() { if (!mEditor) { nsresult rv = PrepareEditor(); NS_ENSURE_SUCCESS(rv, nullptr); } return mEditor; } nsISelectionController* nsTextEditorState::GetSelectionController() const { return mSelCon; } // Helper class, used below in BindToFrame(). class PrepareEditorEvent : public Runnable { public: PrepareEditorEvent(nsTextEditorState &aState, nsIContent *aOwnerContent, const nsAString &aCurrentValue) : mState(&aState) , mOwnerContent(aOwnerContent) , mCurrentValue(aCurrentValue) { aState.mValueTransferInProgress = true; } NS_IMETHOD Run() override { NS_ENSURE_TRUE(mState, NS_ERROR_NULL_POINTER); // Transfer the saved value to the editor if we have one const nsAString *value = nullptr; if (!mCurrentValue.IsEmpty()) { value = &mCurrentValue; } nsAutoScriptBlocker scriptBlocker; mState->PrepareEditor(value); mState->mValueTransferInProgress = false; return NS_OK; } private: WeakPtr mState; nsCOMPtr mOwnerContent; // strong reference nsAutoString mCurrentValue; }; nsresult nsTextEditorState::BindToFrame(nsTextControlFrame* aFrame) { NS_ASSERTION(aFrame, "The frame to bind to should be valid"); NS_ENSURE_ARG_POINTER(aFrame); NS_ASSERTION(!mBoundFrame, "Cannot bind twice, need to unbind first"); NS_ENSURE_TRUE(!mBoundFrame, NS_ERROR_FAILURE); // If we'll need to transfer our current value to the editor, save it before // binding to the frame. nsAutoString currentValue; if (mEditor) { GetValue(currentValue, true); } mBoundFrame = aFrame; nsresult rv = CreateRootNode(); NS_ENSURE_SUCCESS(rv, rv); nsIContent *rootNode = GetRootNode(); rv = InitializeRootNode(); NS_ENSURE_SUCCESS(rv, rv); nsIPresShell *shell = mBoundFrame->PresContext()->GetPresShell(); NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE); // Create selection RefPtr frameSel = new nsFrameSelection(); // Create a SelectionController mSelCon = new nsTextInputSelectionImpl(frameSel, shell, rootNode); MOZ_ASSERT(!mTextListener, "Should not overwrite the object"); mTextListener = new nsTextInputListener(mTextCtrlElement); mTextListener->SetFrame(mBoundFrame); mSelCon->SetDisplaySelection(nsISelectionController::SELECTION_ON); // Get the caret and make it a selection listener. RefPtr domSelection; if (NS_SUCCEEDED(mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(domSelection))) && domSelection) { nsCOMPtr selPriv(do_QueryInterface(domSelection)); RefPtr caret = shell->GetCaret(); nsCOMPtr listener; if (caret) { listener = do_QueryInterface(caret); if (listener) { selPriv->AddSelectionListener(listener); } } selPriv->AddSelectionListener(static_cast (mTextListener)); } // If an editor exists from before, prepare it for usage if (mEditor) { nsCOMPtr content = do_QueryInterface(mTextCtrlElement); NS_ENSURE_TRUE(content, NS_ERROR_FAILURE); // Set the correct direction on the newly created root node uint32_t flags; nsresult rv = mEditor->GetFlags(&flags); NS_ENSURE_SUCCESS(rv, rv); if (flags & nsIPlaintextEditor::eEditorRightToLeft) { rootNode->SetAttr(kNameSpaceID_None, nsGkAtoms::dir, NS_LITERAL_STRING("rtl"), false); } else if (flags & nsIPlaintextEditor::eEditorLeftToRight) { rootNode->SetAttr(kNameSpaceID_None, nsGkAtoms::dir, NS_LITERAL_STRING("ltr"), false); } else { // otherwise, inherit the content node's direction } nsContentUtils::AddScriptRunner( new PrepareEditorEvent(*this, content, currentValue)); } return NS_OK; } struct PreDestroyer { void Init(nsIEditor* aEditor) { mNewEditor = aEditor; } ~PreDestroyer() { if (mNewEditor) { mNewEditor->PreDestroy(true); } } void Swap(nsCOMPtr& aEditor) { return mNewEditor.swap(aEditor); } private: nsCOMPtr mNewEditor; }; nsresult nsTextEditorState::PrepareEditor(const nsAString *aValue) { if (!mBoundFrame) { // Cannot create an editor without a bound frame. // Don't return a failure code, because js callers can't handle that. return NS_OK; } if (mEditorInitialized) { // Do not initialize the editor multiple times. return NS_OK; } AutoHideSelectionChanges hideSelectionChanges(GetConstFrameSelection()); // Don't attempt to initialize recursively! InitializationGuard guard(*this); if (guard.IsInitializingRecursively()) { return NS_ERROR_NOT_INITIALIZED; } // Note that we don't check mEditor here, because we might already have one // around, in which case we don't create a new one, and we'll just tie the // required machinery to it. nsPresContext *presContext = mBoundFrame->PresContext(); nsIPresShell *shell = presContext->GetPresShell(); // Setup the editor flags uint32_t editorFlags = 0; if (IsPlainTextControl()) editorFlags |= nsIPlaintextEditor::eEditorPlaintextMask; if (IsSingleLineTextControl()) editorFlags |= nsIPlaintextEditor::eEditorSingleLineMask; if (IsPasswordTextControl()) editorFlags |= nsIPlaintextEditor::eEditorPasswordMask; // All nsTextControlFrames are widgets editorFlags |= nsIPlaintextEditor::eEditorWidgetMask; // Spell check is diabled at creation time. It is enabled once // the editor comes into focus. editorFlags |= nsIPlaintextEditor::eEditorSkipSpellCheck; bool shouldInitializeEditor = false; nsCOMPtr newEditor; // the editor that we might create nsresult rv = NS_OK; PreDestroyer preDestroyer; if (!mEditor) { shouldInitializeEditor = true; // Create an editor newEditor = do_CreateInstance(kTextEditorCID, &rv); NS_ENSURE_SUCCESS(rv, rv); preDestroyer.Init(newEditor); // Make sure we clear out the non-breaking space before we initialize the editor rv = mBoundFrame->UpdateValueDisplay(true, true); NS_ENSURE_SUCCESS(rv, rv); } else { if (aValue || !mEditorInitialized) { // Set the correct value in the root node rv = mBoundFrame->UpdateValueDisplay(true, !mEditorInitialized, aValue); NS_ENSURE_SUCCESS(rv, rv); } newEditor = mEditor; // just pretend that we have a new editor! // Don't lose application flags in the process. uint32_t originalFlags = 0; newEditor->GetFlags(&originalFlags); if (originalFlags & nsIPlaintextEditor::eEditorMailMask) { editorFlags |= nsIPlaintextEditor::eEditorMailMask; } } // Get the current value of the textfield from the content. // Note that if we've created a new editor, mEditor is null at this stage, // so we will get the real value from the content. nsAutoString defaultValue; if (aValue) { defaultValue = *aValue; } else { GetValue(defaultValue, true); } if (!mEditorInitialized) { // Now initialize the editor. // // NOTE: Conversion of '\n' to
happens inside the // editor's Init() call. // Get the DOM document nsCOMPtr domdoc = do_QueryInterface(shell->GetDocument()); if (!domdoc) return NS_ERROR_FAILURE; // What follows is a bit of a hack. The editor uses the public DOM APIs // for its content manipulations, and it causes it to fail some security // checks deep inside when initializing. So we explictly make it clear that // we're native code. // Note that any script that's directly trying to access our value // has to be going through some scriptable object to do that and that // already does the relevant security checks. AutoNoJSAPI nojsapi; rv = newEditor->Init(domdoc, GetRootNode(), mSelCon, editorFlags, defaultValue); NS_ENSURE_SUCCESS(rv, rv); } // Initialize the controller for the editor if (!SuppressEventHandlers(presContext)) { nsCOMPtr controllers; nsCOMPtr inputElement = do_QueryInterface(mTextCtrlElement); if (inputElement) { rv = inputElement->GetControllers(getter_AddRefs(controllers)); } else { nsCOMPtr textAreaElement = do_QueryInterface(mTextCtrlElement); if (!textAreaElement) return NS_ERROR_FAILURE; rv = textAreaElement->GetControllers(getter_AddRefs(controllers)); } NS_ENSURE_SUCCESS(rv, rv); if (controllers) { uint32_t numControllers; bool found = false; rv = controllers->GetControllerCount(&numControllers); for (uint32_t i = 0; i < numControllers; i ++) { nsCOMPtr controller; rv = controllers->GetControllerAt(i, getter_AddRefs(controller)); if (NS_SUCCEEDED(rv) && controller) { nsCOMPtr editController = do_QueryInterface(controller); if (editController) { editController->SetCommandContext(newEditor); found = true; } } } if (!found) rv = NS_ERROR_FAILURE; } } if (shouldInitializeEditor) { // Initialize the plaintext editor nsCOMPtr textEditor(do_QueryInterface(newEditor)); if (textEditor) { // Set up wrapping textEditor->SetWrapColumn(GetWrapCols()); // Set max text field length int32_t maxLength; if (GetMaxLength(&maxLength)) { textEditor->SetMaxTextLength(maxLength); } } } nsCOMPtr content = do_QueryInterface(mTextCtrlElement); if (content) { rv = newEditor->GetFlags(&editorFlags); NS_ENSURE_SUCCESS(rv, rv); // Check if the readonly attribute is set. if (content->HasAttr(kNameSpaceID_None, nsGkAtoms::readonly)) editorFlags |= nsIPlaintextEditor::eEditorReadonlyMask; // Check if the disabled attribute is set. // TODO: call IsDisabled() here! if (content->HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) editorFlags |= nsIPlaintextEditor::eEditorDisabledMask; // Disable the selection if necessary. if (editorFlags & nsIPlaintextEditor::eEditorDisabledMask) mSelCon->SetDisplaySelection(nsISelectionController::SELECTION_OFF); newEditor->SetFlags(editorFlags); } if (shouldInitializeEditor) { // Hold on to the newly created editor preDestroyer.Swap(mEditor); } // If we have a default value, insert it under the div we created // above, but be sure to use the editor so that '*' characters get // displayed for password fields, etc. SetValue() will call the // editor for us. if (!defaultValue.IsEmpty()) { rv = newEditor->SetFlags(editorFlags); NS_ENSURE_SUCCESS(rv, rv); // Now call SetValue() which will make the necessary editor calls to set // the default value. Make sure to turn off undo before setting the default // value, and turn it back on afterwards. This will make sure we can't undo // past the default value. rv = newEditor->EnableUndo(false); NS_ENSURE_SUCCESS(rv, rv); bool success = SetValue(defaultValue, eSetValue_Internal); NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY); rv = newEditor->EnableUndo(true); NS_ASSERTION(NS_SUCCEEDED(rv),"Transaction Manager must have failed"); // Now restore the original editor flags. rv = newEditor->SetFlags(editorFlags); NS_ENSURE_SUCCESS(rv, rv); } nsCOMPtr transMgr; newEditor->GetTransactionManager(getter_AddRefs(transMgr)); NS_ENSURE_TRUE(transMgr, NS_ERROR_FAILURE); transMgr->SetMaxTransactionCount(nsITextControlElement::DEFAULT_UNDO_CAP); if (IsPasswordTextControl()) { // Disable undo for password textfields. Note that we want to do this at // the very end of InitEditor, so the calls to EnableUndo when setting the // default value don't screw us up. // Since changing the control type does a reframe, we don't have to worry // about dynamic type changes here. newEditor->EnableUndo(false); } if (!mEditorInitialized) { newEditor->PostCreate(); mEverInited = true; mEditorInitialized = true; } if (mTextListener) newEditor->AddEditorObserver(mTextListener); // Restore our selection after being bound to a new frame HTMLInputElement* number = GetParentNumberControl(mBoundFrame); if (number ? number->IsSelectionCached() : mSelectionCached) { if (mRestoringSelection) // paranoia mRestoringSelection->Revoke(); mRestoringSelection = new RestoreSelectionState(this, mBoundFrame); if (mRestoringSelection) { nsContentUtils::AddScriptRunner(mRestoringSelection); } } // The selection cache is no longer going to be valid. // // XXXbz Shouldn't we do this at the point when we're actually about to // restore the properties or something? As things stand, if UnbindFromFrame // happens before our RestoreSelectionState runs, it looks like we'll lose our // selection info, because we will think we don't have it cached and try to // read it from the selection controller, which will not have it yet. if (number) { number->ClearSelectionCached(); } else { mSelectionCached = false; } return rv; } void nsTextEditorState::FinishedRestoringSelection() { mRestoringSelection = nullptr; } bool nsTextEditorState::IsSelectionCached() const { if (mBoundFrame) { HTMLInputElement* number = GetParentNumberControl(mBoundFrame); if (number) { return number->IsSelectionCached(); } } return mSelectionCached; } nsTextEditorState::SelectionProperties& nsTextEditorState::GetSelectionProperties() { if (mBoundFrame) { HTMLInputElement* number = GetParentNumberControl(mBoundFrame); if (number) { return number->GetSelectionProperties(); } } return mSelectionProperties; } void nsTextEditorState::SyncUpSelectionPropertiesBeforeDestruction() { if (mBoundFrame) { UnbindFromFrame(mBoundFrame); } } void nsTextEditorState::SetSelectionProperties(nsTextEditorState::SelectionProperties& aProps) { if (mBoundFrame) { mBoundFrame->SetSelectionRange(aProps.GetStart(), aProps.GetEnd(), aProps.GetDirection()); } else { mSelectionProperties = aProps; } } void nsTextEditorState::GetSelectionRange(int32_t* aSelectionStart, int32_t* aSelectionEnd, ErrorResult& aRv) { MOZ_ASSERT(aSelectionStart); MOZ_ASSERT(aSelectionEnd); MOZ_ASSERT(IsSelectionCached() || GetSelectionController(), "How can we not have a cached selection if we have no selection " "controller?"); // Note that we may have both IsSelectionCached() _and_ // GetSelectionController() if we haven't initialized our editor yet. if (IsSelectionCached()) { const SelectionProperties& props = GetSelectionProperties(); *aSelectionStart = props.GetStart(); *aSelectionEnd = props.GetEnd(); return; } nsISelectionController* selCon = GetSelectionController(); nsCOMPtr selection; nsresult rv = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection)); if (NS_WARN_IF(NS_FAILED(rv))) { aRv.Throw(rv); return; } if (NS_WARN_IF(!selection)) { aRv.Throw(NS_ERROR_FAILURE); return; } dom::Selection* sel = selection->AsSelection(); mozilla::dom::Element* root = GetRootNode(); if (NS_WARN_IF(!root)) { aRv.Throw(NS_ERROR_UNEXPECTED); return; } nsContentUtils::GetSelectionInTextControl(sel, root, *aSelectionStart, *aSelectionEnd); } nsITextControlFrame::SelectionDirection nsTextEditorState::GetSelectionDirection(ErrorResult& aRv) { MOZ_ASSERT(IsSelectionCached() || GetSelectionController(), "How can we not have a cached selection if we have no selection " "controller?"); // Note that we may have both IsSelectionCached() _and_ // GetSelectionController() if we haven't initialized our editor yet. if (IsSelectionCached()) { return GetSelectionProperties().GetDirection(); } nsISelectionController* selCon = GetSelectionController(); nsCOMPtr selection; nsresult rv = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection)); if (NS_WARN_IF(NS_FAILED(rv))) { aRv.Throw(rv); return nsITextControlFrame::eForward; // Doesn't really matter } if (NS_WARN_IF(!selection)) { aRv.Throw(NS_ERROR_FAILURE); return nsITextControlFrame::eForward; // Doesn't really matter } dom::Selection* sel = selection->AsSelection(); nsDirection direction = sel->GetSelectionDirection(); if (direction == eDirNext) { return nsITextControlFrame::eForward; } MOZ_ASSERT(direction == eDirPrevious); return nsITextControlFrame::eBackward; } void nsTextEditorState::SetSelectionRange(int32_t aStart, int32_t aEnd, nsITextControlFrame::SelectionDirection aDirection, ErrorResult& aRv) { MOZ_ASSERT(IsSelectionCached() || mBoundFrame, "How can we have a non-cached selection but no frame?"); if (aStart > aEnd) { aStart = aEnd; } bool changed = false; nsresult rv = NS_OK; // For the ScrollSelectionIntoView() return value. if (IsSelectionCached()) { nsAutoString value; // XXXbz is "false" the right thing to pass here? Hard to tell, given the // various mismatches between our impl and the spec. GetValue(value, false); uint32_t length = value.Length(); if (uint32_t(aStart) > length) { aStart = length; } if (uint32_t(aEnd) > length) { aEnd = length; } SelectionProperties& props = GetSelectionProperties(); changed = props.GetStart() != aStart || props.GetEnd() != aEnd || props.GetDirection() != aDirection; props.SetStart(aStart); props.SetEnd(aEnd); props.SetDirection(aDirection); } else { aRv = mBoundFrame->SetSelectionRange(aStart, aEnd, aDirection); if (aRv.Failed()) { return; } rv = mBoundFrame->ScrollSelectionIntoView(); // Press on to firing the event even if that failed, like our old code did. // But is that really what we want? Firing the event _and_ throwing from // here is weird. Maybe we should just ignore ScrollSelectionIntoView // failures? // XXXbz This is preserving our current behavior of firing a "select" event // on all mutations when we have an editor, but we should really consider // fixing that... changed = true; } if (changed) { // It sure would be nice if we had an existing Element* or so to work with. nsCOMPtr node = do_QueryInterface(mTextCtrlElement); RefPtr asyncDispatcher = new AsyncEventDispatcher(node, NS_LITERAL_STRING("select"), true, false); asyncDispatcher->PostDOMEvent(); } if (NS_FAILED(rv)) { aRv.Throw(rv); } } HTMLInputElement* nsTextEditorState::GetParentNumberControl(nsFrame* aFrame) const { MOZ_ASSERT(aFrame); nsIContent* content = aFrame->GetContent(); MOZ_ASSERT(content); nsIContent* parent = content->GetParent(); if (!parent) { return nullptr; } nsIContent* parentOfParent = parent->GetParent(); if (!parentOfParent) { return nullptr; } HTMLInputElement* input = HTMLInputElement::FromContent(parentOfParent); if (input) { // This function might be called during frame reconstruction as a result // of changing the input control's type from number to something else. In // that situation, the type of the control has changed, but its frame has // not been reconstructed yet. So we need to check the type of the input // control in addition to the type of the frame. return (input->GetType() == NS_FORM_INPUT_NUMBER) ? input : nullptr; } return nullptr; } void nsTextEditorState::DestroyEditor() { // notify the editor that we are going away if (mEditorInitialized) { if (mTextListener) mEditor->RemoveEditorObserver(mTextListener); mEditor->PreDestroy(true); mEditorInitialized = false; } ClearValueCache(); } void nsTextEditorState::UnbindFromFrame(nsTextControlFrame* aFrame) { NS_ENSURE_TRUE_VOID(mBoundFrame); // If it was, however, it should be unbounded from the same frame. NS_ASSERTION(!aFrame || aFrame == mBoundFrame, "Unbinding from the wrong frame"); NS_ENSURE_TRUE_VOID(!aFrame || aFrame == mBoundFrame); // If the editor is modified but nsIEditorObserver::EditAction() hasn't been // called yet, we need to notify it here because editor may be destroyed // before EditAction() is called if selection listener causes flushing layout. bool isInEditAction = false; if (mTextListener && mEditor && mEditorInitialized && NS_SUCCEEDED(mEditor->GetIsInEditAction(&isInEditAction)) && isInEditAction) { mTextListener->EditAction(); } // We need to start storing the value outside of the editor if we're not // going to use it anymore, so retrieve it for now. nsAutoString value; GetValue(value, true); if (mRestoringSelection) { mRestoringSelection->Revoke(); mRestoringSelection = nullptr; } // Save our selection state if needed. // Note that GetSelectionRange will attempt to work with our selection // controller, so we should make sure we do it before we start doing things // like destroying our editor (if we have one), tearing down the selection // controller, and so forth. if (!IsSelectionCached()) { // Go ahead and cache it now. int32_t start = 0, end = 0; IgnoredErrorResult rangeRv; GetSelectionRange(&start, &end, rangeRv); IgnoredErrorResult dirRv; nsITextControlFrame::SelectionDirection direction = GetSelectionDirection(dirRv); MOZ_ASSERT(aFrame == mBoundFrame); SelectionProperties& props = GetSelectionProperties(); props.SetStart(start); props.SetEnd(end); props.SetDirection(direction); HTMLInputElement* number = GetParentNumberControl(aFrame); if (number) { // If we are inside a number control, cache the selection on the // parent control, because this text editor state will be destroyed // together with the native anonymous text control. number->SetSelectionCached(); } else { mSelectionCached = true; } } // Destroy our editor DestroyEditor(); // Clean up the controller if (!SuppressEventHandlers(mBoundFrame->PresContext())) { nsCOMPtr controllers; nsCOMPtr inputElement = do_QueryInterface(mTextCtrlElement); if (inputElement) inputElement->GetControllers(getter_AddRefs(controllers)); else { nsCOMPtr textAreaElement = do_QueryInterface(mTextCtrlElement); if (textAreaElement) { textAreaElement->GetControllers(getter_AddRefs(controllers)); } } if (controllers) { uint32_t numControllers; nsresult rv = controllers->GetControllerCount(&numControllers); NS_ASSERTION((NS_SUCCEEDED(rv)), "bad result in gfx text control destructor"); for (uint32_t i = 0; i < numControllers; i ++) { nsCOMPtr controller; rv = controllers->GetControllerAt(i, getter_AddRefs(controller)); if (NS_SUCCEEDED(rv) && controller) { nsCOMPtr editController = do_QueryInterface(controller); if (editController) { editController->SetCommandContext(nullptr); } } } } } if (mSelCon) { if (mTextListener) { RefPtr domSelection; if (NS_SUCCEEDED(mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(domSelection))) && domSelection) { nsCOMPtr selPriv(do_QueryInterface(domSelection)); selPriv->RemoveSelectionListener(static_cast (mTextListener)); } } mSelCon->SetScrollableFrame(nullptr); mSelCon = nullptr; } if (mTextListener) { mTextListener->SetFrame(nullptr); nsCOMPtr target = do_QueryInterface(mTextCtrlElement); EventListenerManager* manager = target->GetExistingListenerManager(); if (manager) { manager->RemoveEventListenerByType(mTextListener, NS_LITERAL_STRING("keydown"), TrustedEventsAtSystemGroupBubble()); manager->RemoveEventListenerByType(mTextListener, NS_LITERAL_STRING("keypress"), TrustedEventsAtSystemGroupBubble()); manager->RemoveEventListenerByType(mTextListener, NS_LITERAL_STRING("keyup"), TrustedEventsAtSystemGroupBubble()); } mTextListener = nullptr; } mBoundFrame = nullptr; // Now that we don't have a frame any more, store the value in the text buffer. // The only case where we don't do this is if a value transfer is in progress. if (!mValueTransferInProgress) { bool success = SetValue(value, eSetValue_Internal); // TODO Find something better to do if this fails... NS_ENSURE_TRUE_VOID(success); } if (mRootNode && mMutationObserver) { mRootNode->RemoveMutationObserver(mMutationObserver); mMutationObserver = nullptr; } // Unbind the anonymous content from the tree. // We actually hold a reference to the content nodes so that // they're not actually destroyed. nsContentUtils::DestroyAnonymousContent(&mRootNode); nsContentUtils::DestroyAnonymousContent(&mPlaceholderDiv); } nsresult nsTextEditorState::CreateRootNode() { MOZ_ASSERT(!mRootNode); MOZ_ASSERT(mBoundFrame); nsIPresShell *shell = mBoundFrame->PresContext()->GetPresShell(); NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE); nsIDocument *doc = shell->GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); // Now create a DIV and add it to the anonymous content child list. RefPtr nodeInfo; nodeInfo = doc->NodeInfoManager()->GetNodeInfo(nsGkAtoms::div, nullptr, kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE); nsresult rv = NS_NewHTMLElement(getter_AddRefs(mRootNode), nodeInfo.forget(), NOT_FROM_PARSER); NS_ENSURE_SUCCESS(rv, rv); if (!IsSingleLineTextControl()) { mMutationObserver = new nsAnonDivObserver(this); mRootNode->AddMutationObserver(mMutationObserver); } return rv; } nsresult nsTextEditorState::InitializeRootNode() { // Make our root node editable mRootNode->SetFlags(NODE_IS_EDITABLE); // Set the necessary classes on the text control. We use class values // instead of a 'style' attribute so that the style comes from a user-agent // style sheet and is still applied even if author styles are disabled. nsAutoString classValue; classValue.AppendLiteral("anonymous-div"); int32_t wrapCols = GetWrapCols(); if (wrapCols > 0) { classValue.AppendLiteral(" wrap"); } if (!IsSingleLineTextControl()) { // We can't just inherit the overflow because setting visible overflow will // crash when the number of lines exceeds the height of the textarea and // setting -moz-hidden-unscrollable overflow (NS_STYLE_OVERFLOW_CLIP) // doesn't paint the caret for some reason. const nsStyleDisplay* disp = mBoundFrame->StyleDisplay(); if (disp->mOverflowX != NS_STYLE_OVERFLOW_VISIBLE && disp->mOverflowX != NS_STYLE_OVERFLOW_CLIP) { classValue.AppendLiteral(" inherit-overflow"); } classValue.AppendLiteral(" inherit-scroll-behavior"); } nsresult rv = mRootNode->SetAttr(kNameSpaceID_None, nsGkAtoms::_class, classValue, false); NS_ENSURE_SUCCESS(rv, rv); return mBoundFrame->UpdateValueDisplay(false); } nsresult nsTextEditorState::CreatePlaceholderNode() { #ifdef DEBUG { nsCOMPtr content = do_QueryInterface(mTextCtrlElement); if (content) { nsAutoString placeholderTxt; content->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder, placeholderTxt); nsContentUtils::RemoveNewlines(placeholderTxt); NS_ASSERTION(!placeholderTxt.IsEmpty(), "CreatePlaceholderNode() shouldn't \ be called if @placeholder is the empty string when trimmed from line breaks"); } } #endif // DEBUG NS_ENSURE_TRUE(!mPlaceholderDiv, NS_ERROR_UNEXPECTED); NS_ENSURE_ARG_POINTER(mBoundFrame); nsIPresShell *shell = mBoundFrame->PresContext()->GetPresShell(); NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE); nsIDocument *doc = shell->GetDocument(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); nsNodeInfoManager* pNodeInfoManager = doc->NodeInfoManager(); NS_ENSURE_TRUE(pNodeInfoManager, NS_ERROR_OUT_OF_MEMORY); nsresult rv; // Create a DIV for the placeholder // and add it to the anonymous content child list RefPtr nodeInfo; nodeInfo = pNodeInfoManager->GetNodeInfo(nsGkAtoms::div, nullptr, kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE); rv = NS_NewHTMLElement(getter_AddRefs(mPlaceholderDiv), nodeInfo.forget(), NOT_FROM_PARSER); NS_ENSURE_SUCCESS(rv, rv); // Create the text node for the placeholder text before doing anything else RefPtr placeholderText = new nsTextNode(pNodeInfoManager); rv = mPlaceholderDiv->AppendChildTo(placeholderText, false); NS_ENSURE_SUCCESS(rv, rv); // initialize the text UpdatePlaceholderText(false); return NS_OK; } bool nsTextEditorState::GetMaxLength(int32_t* aMaxLength) { nsCOMPtr content = do_QueryInterface(mTextCtrlElement); nsGenericHTMLElement* element = nsGenericHTMLElement::FromContentOrNull(content); NS_ENSURE_TRUE(element, false); const nsAttrValue* attr = element->GetParsedAttr(nsGkAtoms::maxlength); if (attr && attr->Type() == nsAttrValue::eInteger) { *aMaxLength = attr->GetIntegerValue(); return true; } return false; } void nsTextEditorState::GetValue(nsAString& aValue, bool aIgnoreWrap) const { // While SetValue() is being called and requesting to commit composition to // IME, GetValue() may be called for appending text or something. Then, we // need to return the latest aValue of SetValue() since the value hasn't // been set to the editor yet. if (mIsCommittingComposition) { aValue = mValueBeingSet; return; } if (mEditor && mBoundFrame && (mEditorInitialized || !IsSingleLineTextControl())) { bool canCache = aIgnoreWrap && !IsSingleLineTextControl(); if (canCache && !mCachedValue.IsEmpty()) { aValue = mCachedValue; return; } aValue.Truncate(); // initialize out param uint32_t flags = (nsIDocumentEncoder::OutputLFLineBreak | nsIDocumentEncoder::OutputPreformatted | nsIDocumentEncoder::OutputPersistNBSP); if (IsPlainTextControl()) { flags |= nsIDocumentEncoder::OutputBodyOnly; } if (!aIgnoreWrap) { nsITextControlElement::nsHTMLTextWrap wrapProp; nsCOMPtr content = do_QueryInterface(mTextCtrlElement); if (content && nsITextControlElement::GetWrapPropertyEnum(content, wrapProp) && wrapProp == nsITextControlElement::eHTMLTextWrap_Hard) { flags |= nsIDocumentEncoder::OutputWrap; } } // What follows is a bit of a hack. The problem is that we could be in // this method because we're being destroyed for whatever reason while // script is executing. If that happens, editor will run with the // privileges of the executing script, which means it may not be able to // access its own DOM nodes! Let's try to deal with that by pushing a null // JSContext on the JSContext stack to make it clear that we're native // code. Note that any script that's directly trying to access our value // has to be going through some scriptable object to do that and that // already does the relevant security checks. // XXXbz if we could just get the textContent of our anonymous content (eg // if plaintext editor didn't create
nodes all over), we wouldn't need // this. { /* Scope for AutoNoJSAPI. */ AutoNoJSAPI nojsapi; mEditor->OutputToString(NS_LITERAL_STRING("text/plain"), flags, aValue); } if (canCache) { mCachedValue = aValue; } else { mCachedValue.Truncate(); } } else { if (!mTextCtrlElement->ValueChanged() || !mValue) { mTextCtrlElement->GetDefaultValueFromContent(aValue); } else { aValue = *mValue; } } } bool nsTextEditorState::SetValue(const nsAString& aValue, uint32_t aFlags) { nsAutoString newValue(aValue); // While mIsCommittingComposition is true (that means that some event // handlers which are fired during committing composition are the caller of // this method), GetValue() uses mValueBeingSet for its result because the // first calls of this methods hasn't set the value yet. So, when it's true, // we need to modify mValueBeingSet. In this case, we will back to the first // call of this method, then, mValueBeingSet will be truncated when // mIsCommittingComposition is set false. See below. if (mIsCommittingComposition) { mValueBeingSet = aValue; } // Note that if this may be called during reframe of the editor. In such // case, we shouldn't commit composition. Therefore, when this is called // for internal processing, we shouldn't commit the composition. if (aFlags & (eSetValue_BySetUserInput | eSetValue_ByContent)) { if (EditorHasComposition()) { // When this is called recursively, there shouldn't be composition. if (NS_WARN_IF(mIsCommittingComposition)) { // Don't request to commit composition again. But if it occurs, // we should skip to set the new value to the editor here. It should // be set later with the updated mValueBeingSet. return true; } if (NS_WARN_IF(!mBoundFrame)) { // We're not sure if this case is possible. } else { // If setting value won't change current value, we shouldn't commit // composition for compatibility with the other browsers. nsAutoString currentValue; mBoundFrame->GetText(currentValue); if (newValue == currentValue) { // Note that in this case, we shouldn't fire any events with setting // value because event handlers may try to set value recursively but // we cannot commit composition at that time due to unsafe to run // script (see below). return true; } } // If there is composition, need to commit composition first because // other browsers do that. // NOTE: We don't need to block nested calls of this because input nor // other events won't be fired by setting values and script blocker // is used during setting the value to the editor. IE also allows // to set the editor value on the input event which is caused by // forcibly committing composition. if (nsContentUtils::IsSafeToRunScript()) { WeakPtr self(this); // WARNING: During this call, compositionupdate, compositionend, input // events will be fired. Therefore, everything can occur. E.g., the // document may be unloaded. mValueBeingSet = aValue; mIsCommittingComposition = true; nsresult rv = mEditor->ForceCompositionEnd(); if (!self.get()) { return true; } mIsCommittingComposition = false; // If this is called recursively during committing composition and // some of them may be skipped above. Therefore, we need to set // value to the editor with the aValue of the latest call. newValue = mValueBeingSet; // When mIsCommittingComposition is false, mValueBeingSet won't be // used. Therefore, let's clear it. mValueBeingSet.Truncate(); if (NS_FAILED(rv)) { NS_WARNING("nsTextEditorState failed to commit composition"); return true; } } else { NS_WARNING("SetValue() is called when there is composition but " "it's not safe to request to commit the composition"); } } } if (mEditor && mBoundFrame) { // The InsertText call below might flush pending notifications, which // could lead into a scheduled PrepareEditor to be called. That will // lead to crashes (or worse) because we'd be initializing the editor // before InsertText returns. This script blocker makes sure that // PrepareEditor cannot be called prematurely. nsAutoScriptBlocker scriptBlocker; #ifdef DEBUG if (IsSingleLineTextControl()) { NS_ASSERTION(mEditorInitialized || mInitializing, "We should never try to use the editor if we're not initialized unless we're being initialized"); } #endif nsAutoString currentValue; mBoundFrame->GetText(currentValue); AutoWeakFrame weakFrame(mBoundFrame); // this is necessary to avoid infinite recursion if (!currentValue.Equals(newValue)) { ValueSetter valueSetter(mEditor); // \r is an illegal character in the dom, but people use them, // so convert windows and mac platform linebreaks to \n: if (newValue.FindChar(char16_t('\r')) != -1) { if (!nsContentUtils::PlatformToDOMLineBreaks(newValue, fallible)) { return false; } } nsCOMPtr domDoc; mEditor->GetDocument(getter_AddRefs(domDoc)); if (!domDoc) { NS_WARNING("Why don't we have a document?"); return true; } // Time to mess with our security context... See comments in GetValue() // for why this is needed. Note that we have to do this up here, because // otherwise SelectAll() will fail. { AutoNoJSAPI nojsapi; nsCOMPtr domSel; nsCOMPtr selPriv; mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(domSel)); if (domSel) { selPriv = do_QueryInterface(domSel); if (selPriv) selPriv->StartBatchChanges(); } nsCOMPtr kungFuDeathGrip = mSelCon.get(); uint32_t currentLength = currentValue.Length(); uint32_t newlength = newValue.Length(); if (!currentLength || !StringBeginsWith(newValue, currentValue)) { // Replace the whole text. currentLength = 0; kungFuDeathGrip->SelectAll(); } else { // Collapse selection to the end so that we can append data. mBoundFrame->SelectAllOrCollapseToEndOfText(false); } const nsAString& insertValue = StringTail(newValue, newlength - currentLength); nsCOMPtr plaintextEditor = do_QueryInterface(mEditor); if (!plaintextEditor || !weakFrame.IsAlive()) { NS_WARNING("Somehow not a plaintext editor?"); return true; } valueSetter.Init(); // get the flags, remove readonly and disabled, set the value, // restore flags uint32_t flags, savedFlags; mEditor->GetFlags(&savedFlags); flags = savedFlags; flags &= ~(nsIPlaintextEditor::eEditorDisabledMask); flags &= ~(nsIPlaintextEditor::eEditorReadonlyMask); flags |= nsIPlaintextEditor::eEditorDontEchoPassword; mEditor->SetFlags(flags); mTextListener->SettingValue(true); bool notifyValueChanged = !!(aFlags & eSetValue_Notify); mTextListener->SetValueChanged(notifyValueChanged); // Also don't enforce max-length here int32_t savedMaxLength; plaintextEditor->GetMaxTextLength(&savedMaxLength); plaintextEditor->SetMaxTextLength(-1); if (insertValue.IsEmpty()) { mEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip); } else { plaintextEditor->InsertText(insertValue); } mTextListener->SetValueChanged(true); mTextListener->SettingValue(false); if (!weakFrame.IsAlive()) { // If the frame was destroyed because of a flush somewhere inside // InsertText, mBoundFrame here will be false. But it's also possible // for the frame to go away because of another reason (such as deleting // the existing selection -- see bug 574558), in which case we don't // need to reset the value here. if (!mBoundFrame) { return SetValue(newValue, aFlags & eSetValue_Notify); } return true; } if (!IsSingleLineTextControl()) { if (!mCachedValue.Assign(newValue, fallible)) { return false; } } plaintextEditor->SetMaxTextLength(savedMaxLength); mEditor->SetFlags(savedFlags); if (selPriv) selPriv->EndBatchChanges(); } } } else { if (!mValue) { mValue.emplace(); } nsString value; if (!value.Assign(newValue, fallible)) { return false; } if (!nsContentUtils::PlatformToDOMLineBreaks(value, fallible)) { return false; } if (!mValue->Assign(value, fallible)) { return false; } // Since we have no editor we presumably have cached selection state. if (IsSelectionCached()) { SelectionProperties& props = GetSelectionProperties(); if (aFlags & eSetValue_MoveCursorToEnd) { props.SetStart(value.Length()); props.SetEnd(value.Length()); } else { // Make sure our cached selection position is not outside the new value. props.SetStart(std::min(uint32_t(props.GetStart()), value.Length())); props.SetEnd(std::min(uint32_t(props.GetEnd()), value.Length())); } } // Update the frame display if needed if (mBoundFrame) { mBoundFrame->UpdateValueDisplay(true); } } // If we've reached the point where the root node has been created, we // can assume that it's safe to notify. ValueWasChanged(!!mRootNode); mTextCtrlElement->OnValueChanged(/* aNotify = */ !!mRootNode, /* aWasInteractiveUserChange = */ false); return true; } void nsTextEditorState::InitializeKeyboardEventListeners() { //register key listeners nsCOMPtr target = do_QueryInterface(mTextCtrlElement); EventListenerManager* manager = target->GetOrCreateListenerManager(); if (manager) { manager->AddEventListenerByType(mTextListener, NS_LITERAL_STRING("keydown"), TrustedEventsAtSystemGroupBubble()); manager->AddEventListenerByType(mTextListener, NS_LITERAL_STRING("keypress"), TrustedEventsAtSystemGroupBubble()); manager->AddEventListenerByType(mTextListener, NS_LITERAL_STRING("keyup"), TrustedEventsAtSystemGroupBubble()); } mSelCon->SetScrollableFrame(do_QueryFrame(mBoundFrame->PrincipalChildList().FirstChild())); } void nsTextEditorState::ValueWasChanged(bool aNotify) { UpdatePlaceholderVisibility(aNotify); } void nsTextEditorState::UpdatePlaceholderText(bool aNotify) { NS_ASSERTION(mPlaceholderDiv, "This function should not be called if " "mPlaceholderDiv isn't set"); // If we don't have a placeholder div, there's nothing to do. if (!mPlaceholderDiv) return; nsAutoString placeholderValue; nsCOMPtr content = do_QueryInterface(mTextCtrlElement); content->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder, placeholderValue); nsContentUtils::RemoveNewlines(placeholderValue); NS_ASSERTION(mPlaceholderDiv->GetFirstChild(), "placeholder div has no child"); mPlaceholderDiv->GetFirstChild()->SetText(placeholderValue, aNotify); } void nsTextEditorState::UpdatePlaceholderVisibility(bool aNotify) { nsAutoString value; GetValue(value, true); mPlaceholderVisibility = value.IsEmpty(); if (mPlaceholderVisibility && !Preferences::GetBool("dom.placeholder.show_on_focus", true)) { nsCOMPtr content = do_QueryInterface(mTextCtrlElement); mPlaceholderVisibility = !nsContentUtils::IsFocusedContent(content); } if (mBoundFrame && aNotify) { mBoundFrame->InvalidateFrame(); } } void nsTextEditorState::HideSelectionIfBlurred() { MOZ_ASSERT(mSelCon, "Should have a selection controller if we have a frame!"); nsCOMPtr content = do_QueryInterface(mTextCtrlElement); if (!nsContentUtils::IsFocusedContent(content)) { mSelCon->SetDisplaySelection(nsISelectionController::SELECTION_HIDDEN); } } bool nsTextEditorState::EditorHasComposition() { bool isComposing = false; return mEditor && NS_SUCCEEDED(mEditor->GetComposing(&isComposing)) && isComposing; } NS_IMPL_ISUPPORTS(nsAnonDivObserver, nsIMutationObserver) void nsAnonDivObserver::CharacterDataChanged(nsIDocument* aDocument, nsIContent* aContent, CharacterDataChangeInfo* aInfo) { mTextEditorState->ClearValueCache(); } void nsAnonDivObserver::ContentAppended(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aFirstNewContent, int32_t /* unused */) { mTextEditorState->ClearValueCache(); } void nsAnonDivObserver::ContentInserted(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aChild, int32_t /* unused */) { mTextEditorState->ClearValueCache(); } void nsAnonDivObserver::ContentRemoved(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aChild, int32_t aIndexInContainer, nsIContent* aPreviousSibling) { mTextEditorState->ClearValueCache(); }