/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "mozilla/DebugOnly.h" #include "nsCOMPtr.h" #include "nsFontMetrics.h" #include "nsTextControlFrame.h" #include "nsIPlaintextEditor.h" #include "nsCaret.h" #include "nsCSSPseudoElements.h" #include "nsGenericHTMLElement.h" #include "nsIEditor.h" #include "nsIEditorIMESupport.h" #include "nsIPhonetic.h" #include "nsTextFragment.h" #include "nsIDOMHTMLTextAreaElement.h" #include "nsNameSpaceManager.h" #include "nsFormControlFrame.h" //for registering accesskeys #include "nsIContent.h" #include "nsPresContext.h" #include "nsRenderingContext.h" #include "nsGkAtoms.h" #include "nsLayoutUtils.h" #include "nsIDOMElement.h" #include "nsIDOMHTMLElement.h" #include "nsIPresShell.h" #include <algorithm> #include "nsIDOMNodeList.h" //for selection setting helper func #include "nsIDOMRange.h" //for selection setting helper func #include "nsPIDOMWindow.h" //needed for notify selection changed to update the menus ect. #include "nsIDOMNode.h" #include "nsIDOMText.h" //for multiline getselection #include "nsFocusManager.h" #include "nsPresState.h" #include "nsContentList.h" #include "nsAttrValueInlines.h" #include "mozilla/dom/Selection.h" #include "mozilla/TextEditRules.h" #include "nsContentUtils.h" #include "nsTextNode.h" #include "mozilla/StyleSetHandle.h" #include "mozilla/StyleSetHandleInlines.h" #include "mozilla/dom/HTMLInputElement.h" #include "mozilla/dom/HTMLTextAreaElement.h" #include "mozilla/dom/ScriptSettings.h" #include "mozilla/MathAlgorithms.h" #include "nsFrameSelection.h" #define DEFAULT_COLUMN_WIDTH 20 using namespace mozilla; nsIFrame* NS_NewTextControlFrame(nsIPresShell* aPresShell, nsStyleContext* aContext) { return new (aPresShell) nsTextControlFrame(aContext); } NS_IMPL_FRAMEARENA_HELPERS(nsTextControlFrame) NS_QUERYFRAME_HEAD(nsTextControlFrame) NS_QUERYFRAME_ENTRY(nsIFormControlFrame) NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator) NS_QUERYFRAME_ENTRY(nsITextControlFrame) NS_QUERYFRAME_ENTRY(nsIStatefulFrame) NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) #ifdef ACCESSIBILITY a11y::AccType nsTextControlFrame::AccessibleType() { return a11y::eHTMLTextFieldType; } #endif #ifdef DEBUG class EditorInitializerEntryTracker { public: explicit EditorInitializerEntryTracker(nsTextControlFrame &frame) : mFrame(frame) , mFirstEntry(false) { if (!mFrame.mInEditorInitialization) { mFrame.mInEditorInitialization = true; mFirstEntry = true; } } ~EditorInitializerEntryTracker() { if (mFirstEntry) { mFrame.mInEditorInitialization = false; } } bool EnteredMoreThanOnce() const { return !mFirstEntry; } private: nsTextControlFrame &mFrame; bool mFirstEntry; }; #endif nsTextControlFrame::nsTextControlFrame(nsStyleContext* aContext) : nsContainerFrame(aContext) , mFirstBaseline(NS_INTRINSIC_WIDTH_UNKNOWN) , mEditorHasBeenInitialized(false) , mIsProcessing(false) #ifdef DEBUG , mInEditorInitialization(false) #endif { } nsTextControlFrame::~nsTextControlFrame() { } void nsTextControlFrame::DestroyFrom(nsIFrame* aDestructRoot) { mScrollEvent.Revoke(); EditorInitializer* initializer = Properties().Get(TextControlInitializer()); if (initializer) { initializer->Revoke(); Properties().Delete(TextControlInitializer()); } // Unbind the text editor state object from the frame. The editor will live // on, but things like controllers will be released. nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); txtCtrl->UnbindFromFrame(this); nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false); nsContainerFrame::DestroyFrom(aDestructRoot); } nsIAtom* nsTextControlFrame::GetType() const { return nsGkAtoms::textInputFrame; } LogicalSize nsTextControlFrame::CalcIntrinsicSize(nsRenderingContext* aRenderingContext, WritingMode aWM, float aFontSizeInflation) const { LogicalSize intrinsicSize(aWM); // Get leading and the Average/MaxAdvance char width nscoord lineHeight = 0; nscoord charWidth = 0; nscoord charMaxAdvance = 0; RefPtr<nsFontMetrics> fontMet = nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation); lineHeight = ReflowInput::CalcLineHeight(GetContent(), StyleContext(), NS_AUTOHEIGHT, aFontSizeInflation); charWidth = fontMet->AveCharWidth(); charMaxAdvance = fontMet->MaxAdvance(); // Set the width equal to the width in characters int32_t cols = GetCols(); intrinsicSize.ISize(aWM) = cols * charWidth; // To better match IE, take the maximum character width(in twips) and remove // 4 pixels add this on as additional padding(internalPadding). But only do // this if we think we have a fixed-width font. if (mozilla::Abs(charWidth - charMaxAdvance) > (unsigned)nsPresContext::CSSPixelsToAppUnits(1)) { nscoord internalPadding = std::max(0, charMaxAdvance - nsPresContext::CSSPixelsToAppUnits(4)); nscoord t = nsPresContext::CSSPixelsToAppUnits(1); // Round to a multiple of t nscoord rest = internalPadding % t; if (rest < t - rest) { internalPadding -= rest; } else { internalPadding += t - rest; } // Now add the extra padding on (so that small input sizes work well) intrinsicSize.ISize(aWM) += internalPadding; } else { // This is to account for the anonymous <br> having a 1 twip width // in Full Standards mode, see BRFrame::Reflow and bug 228752. if (PresContext()->CompatibilityMode() == eCompatibility_FullStandards) { intrinsicSize.ISize(aWM) += 1; } } // Increment width with cols * letter-spacing. { const nsStyleCoord& lsCoord = StyleText()->mLetterSpacing; if (eStyleUnit_Coord == lsCoord.GetUnit()) { nscoord letterSpacing = lsCoord.GetCoordValue(); if (letterSpacing != 0) { intrinsicSize.ISize(aWM) += cols * letterSpacing; } } } // Set the height equal to total number of rows (times the height of each // line, of course) intrinsicSize.BSize(aWM) = lineHeight * GetRows(); // Add in the size of the scrollbars for textarea if (IsTextArea()) { nsIFrame* first = PrincipalChildList().FirstChild(); nsIScrollableFrame *scrollableFrame = do_QueryFrame(first); NS_ASSERTION(scrollableFrame, "Child must be scrollable"); if (scrollableFrame) { LogicalMargin scrollbarSizes(aWM, scrollableFrame->GetDesiredScrollbarSizes(PresContext(), aRenderingContext)); intrinsicSize.ISize(aWM) += scrollbarSizes.IStartEnd(aWM); intrinsicSize.BSize(aWM) += scrollbarSizes.BStartEnd(aWM); } } return intrinsicSize; } nsresult nsTextControlFrame::EnsureEditorInitialized() { // This method initializes our editor, if needed. // This code used to be called from CreateAnonymousContent(), but // when the editor set the initial string, it would trigger a // PresShell listener which called FlushPendingNotifications() // during frame construction. This was causing other form controls // to display wrong values. Additionally, calling this every time // a text frame control is instantiated means that we're effectively // instantiating the editor for all text fields, even if they // never get used. So, now this method is being called lazily only // when we actually need an editor. if (mEditorHasBeenInitialized) return NS_OK; nsIDocument* doc = mContent->GetComposedDoc(); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); nsWeakFrame weakFrame(this); // Flush out content on our document. Have to do this, because script // blockers don't prevent the sink flushing out content and notifying in the // process, which can destroy frames. doc->FlushPendingNotifications(Flush_ContentAndNotify); NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_ERROR_FAILURE); // Make sure that editor init doesn't do things that would kill us off // (especially off the script blockers it'll create for its DOM mutations). { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); MOZ_ASSERT(txtCtrl, "Content not a text control element"); // Hide selection changes during the initialization, as webpages should not // be aware of these initializations AutoHideSelectionChanges hideSelectionChanges(txtCtrl->GetConstFrameSelection()); nsAutoScriptBlocker scriptBlocker; // Time to mess with our security context... See comments in GetValue() // for why this is needed. mozilla::dom::AutoNoJSAPI nojsapi; // Make sure that we try to focus the content even if the method fails class EnsureSetFocus { public: explicit EnsureSetFocus(nsTextControlFrame* aFrame) : mFrame(aFrame) {} ~EnsureSetFocus() { if (nsContentUtils::IsFocusedContent(mFrame->GetContent())) mFrame->SetFocus(true, false); } private: nsTextControlFrame *mFrame; }; EnsureSetFocus makeSureSetFocusHappens(this); #ifdef DEBUG // Make sure we are not being called again until we're finished. // If reentrancy happens, just pretend that we don't have an editor. const EditorInitializerEntryTracker tracker(*this); NS_ASSERTION(!tracker.EnteredMoreThanOnce(), "EnsureEditorInitialized has been called while a previous call was in progress"); #endif // Create an editor for the frame, if one doesn't already exist nsresult rv = txtCtrl->CreateEditor(); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_STATE(weakFrame.IsAlive()); // Set mEditorHasBeenInitialized so that subsequent calls will use the // editor. mEditorHasBeenInitialized = true; if (weakFrame.IsAlive()) { int32_t position = 0; // Set the selection to the end of the text field (bug 1287655), // but only if the contents has changed (bug 1337392). if (txtCtrl->ValueChanged()) { nsAutoString val; txtCtrl->GetTextEditorValue(val, true); position = val.Length(); } SetSelectionEndPoints(position, position); } } NS_ENSURE_STATE(weakFrame.IsAlive()); return NS_OK; } nsresult nsTextControlFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements) { NS_ASSERTION(mContent, "We should have a content!"); mState |= NS_FRAME_INDEPENDENT_SELECTION; nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); // Bind the frame to its text control nsresult rv = txtCtrl->BindToFrame(this); NS_ENSURE_SUCCESS(rv, rv); nsIContent* rootNode = txtCtrl->GetRootEditorNode(); NS_ENSURE_TRUE(rootNode, NS_ERROR_OUT_OF_MEMORY); if (!aElements.AppendElement(rootNode)) return NS_ERROR_OUT_OF_MEMORY; // Do we need a placeholder node? nsAutoString placeholderTxt; mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder, placeholderTxt); nsContentUtils::RemoveNewlines(placeholderTxt); mUsePlaceholder = !placeholderTxt.IsEmpty(); // Create the placeholder anonymous content if needed. if (mUsePlaceholder) { nsIContent* placeholderNode = txtCtrl->CreatePlaceholderNode(); NS_ENSURE_TRUE(placeholderNode, NS_ERROR_OUT_OF_MEMORY); // Associate ::placeholder pseudo-element with the placeholder node. CSSPseudoElementType pseudoType = CSSPseudoElementType::placeholder; // If this is a text input inside a number input then we want to use the // main number input as the source of style for the placeholder frame. nsIFrame* mainInputFrame = this; if (StyleContext()->GetPseudoType() == CSSPseudoElementType::mozNumberText) { do { mainInputFrame = mainInputFrame->GetParent(); } while (mainInputFrame && mainInputFrame->GetType() != nsGkAtoms::numberControlFrame); MOZ_ASSERT(mainInputFrame); } RefPtr<nsStyleContext> placeholderStyleContext = PresContext()->StyleSet()->ResolvePseudoElementStyle( mainInputFrame->GetContent()->AsElement(), pseudoType, StyleContext(), placeholderNode->AsElement()); if (!aElements.AppendElement(ContentInfo(placeholderNode, placeholderStyleContext))) { return NS_ERROR_OUT_OF_MEMORY; } if (!IsSingleLineTextControl()) { // For textareas, UpdateValueDisplay doesn't initialize the visibility // status of the placeholder because it returns early, so we have to // do that manually here. txtCtrl->UpdatePlaceholderVisibility(true); } } rv = UpdateValueDisplay(false); NS_ENSURE_SUCCESS(rv, rv); // textareas are eagerly initialized bool initEagerly = !IsSingleLineTextControl(); if (!initEagerly) { // Also, input elements which have a cached selection should get eager // editor initialization. nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); initEagerly = txtCtrl->HasCachedSelection(); } if (!initEagerly) { nsCOMPtr<nsIDOMHTMLElement> element = do_QueryInterface(txtCtrl); if (element) { // so are input text controls with spellcheck=true element->GetSpellcheck(&initEagerly); } } if (initEagerly) { NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(), "Someone forgot a script blocker?"); EditorInitializer* initializer = Properties().Get(TextControlInitializer()); if (initializer) { initializer->Revoke(); } initializer = new EditorInitializer(this); Properties().Set(TextControlInitializer(),initializer); nsContentUtils::AddScriptRunner(initializer); } return NS_OK; } void nsTextControlFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements, uint32_t aFilter) { // This can be called off-main-thread during Servo traversal, so we take care // to avoid QI-ing the DOM node. nsITextControlElement* txtCtrl = nullptr; nsIContent* content = GetContent(); if (content->IsHTMLElement(nsGkAtoms::input)) { txtCtrl = static_cast<HTMLInputElement*>(content); } else if (content->IsHTMLElement(nsGkAtoms::textarea)) { txtCtrl = static_cast<HTMLTextAreaElement*>(content); } else { MOZ_CRASH("Unexpected content type for nsTextControlFrame"); } nsIContent* root = txtCtrl->GetRootEditorNode(); if (root) { aElements.AppendElement(root); } nsIContent* placeholder = txtCtrl->GetPlaceholderNode(); if (placeholder && !(aFilter & nsIContent::eSkipPlaceholderContent)) aElements.AppendElement(placeholder); } nscoord nsTextControlFrame::GetPrefISize(nsRenderingContext* aRenderingContext) { nscoord result = 0; DISPLAY_PREF_WIDTH(this, result); float inflation = nsLayoutUtils::FontSizeInflationFor(this); WritingMode wm = GetWritingMode(); result = CalcIntrinsicSize(aRenderingContext, wm, inflation).ISize(wm); return result; } nscoord nsTextControlFrame::GetMinISize(nsRenderingContext* aRenderingContext) { // Our min width is just our preferred width if we have auto width. nscoord result; DISPLAY_MIN_WIDTH(this, result); result = GetPrefISize(aRenderingContext); return result; } LogicalSize nsTextControlFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize, nscoord aAvailableISize, const LogicalSize& aMargin, const LogicalSize& aBorder, const LogicalSize& aPadding, ComputeSizeFlags aFlags) { float inflation = nsLayoutUtils::FontSizeInflationFor(this); LogicalSize autoSize = CalcIntrinsicSize(aRenderingContext, aWM, inflation); // Note: nsContainerFrame::ComputeAutoSize only computes the inline-size (and // only for 'auto'), the block-size it returns is always NS_UNCONSTRAINEDSIZE. const nsStyleCoord& iSizeCoord = StylePosition()->ISize(aWM); if (iSizeCoord.GetUnit() == eStyleUnit_Auto) { if (aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize) { // CalcIntrinsicSize isn't aware of grid-item margin-box clamping, so we // fall back to nsContainerFrame's ComputeAutoSize to handle that. // XXX maybe a font-inflation issue here? (per the assertion below). autoSize.ISize(aWM) = nsContainerFrame::ComputeAutoSize(aRenderingContext, aWM, aCBSize, aAvailableISize, aMargin, aBorder, aPadding, aFlags).ISize(aWM); } #ifdef DEBUG else { LogicalSize ancestorAutoSize = nsContainerFrame::ComputeAutoSize(aRenderingContext, aWM, aCBSize, aAvailableISize, aMargin, aBorder, aPadding, aFlags); // Disabled when there's inflation; see comment in GetXULPrefSize. MOZ_ASSERT(inflation != 1.0f || ancestorAutoSize.ISize(aWM) == autoSize.ISize(aWM), "Incorrect size computed by ComputeAutoSize?"); } #endif } return autoSize; } void nsTextControlFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, const ReflowInput& aReflowInput, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsTextControlFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus); // make sure that the form registers itself on the initial/first reflow if (mState & NS_FRAME_FIRST_REFLOW) { nsFormControlFrame::RegUnRegAccessKey(this, true); } // set values of reflow's out parameters WritingMode wm = aReflowInput.GetWritingMode(); LogicalSize finalSize(wm, aReflowInput.ComputedISize() + aReflowInput.ComputedLogicalBorderPadding().IStartEnd(wm), aReflowInput.ComputedBSize() + aReflowInput.ComputedLogicalBorderPadding().BStartEnd(wm)); aDesiredSize.SetSize(wm, finalSize); // Calculate the baseline and store it in mFirstBaseline. nscoord lineHeight = aReflowInput.ComputedBSize(); float inflation = nsLayoutUtils::FontSizeInflationFor(this); if (!IsSingleLineTextControl()) { lineHeight = ReflowInput::CalcLineHeight(GetContent(), StyleContext(), NS_AUTOHEIGHT, inflation); } RefPtr<nsFontMetrics> fontMet = nsLayoutUtils::GetFontMetricsForFrame(this, inflation); mFirstBaseline = nsLayoutUtils::GetCenteredFontBaseline(fontMet, lineHeight, wm.IsLineInverted()) + aReflowInput.ComputedLogicalBorderPadding().BStart(wm); aDesiredSize.SetBlockStartAscent(mFirstBaseline); // overflow handling aDesiredSize.SetOverflowAreasToDesiredBounds(); // perform reflow on all kids nsIFrame* kid = mFrames.FirstChild(); while (kid) { ReflowTextControlChild(kid, aPresContext, aReflowInput, aStatus, aDesiredSize); kid = kid->GetNextSibling(); } // take into account css properties that affect overflow handling FinishAndStoreOverflow(&aDesiredSize); aStatus = NS_FRAME_COMPLETE; NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize); } void nsTextControlFrame::ReflowTextControlChild(nsIFrame* aKid, nsPresContext* aPresContext, const ReflowInput& aReflowInput, nsReflowStatus& aStatus, ReflowOutput& aParentDesiredSize) { // compute available size and frame offsets for child WritingMode wm = aKid->GetWritingMode(); LogicalSize availSize = aReflowInput.ComputedSizeWithPadding(wm); availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; ReflowInput kidReflowInput(aPresContext, aReflowInput, aKid, availSize, nullptr, ReflowInput::CALLER_WILL_INIT); // Override padding with our computed padding in case we got it from theming or percentage kidReflowInput.Init(aPresContext, nullptr, nullptr, &aReflowInput.ComputedPhysicalPadding()); // Set computed width and computed height for the child kidReflowInput.SetComputedWidth(aReflowInput.ComputedWidth()); kidReflowInput.SetComputedHeight(aReflowInput.ComputedHeight()); // Offset the frame by the size of the parent's border nscoord xOffset = aReflowInput.ComputedPhysicalBorderPadding().left - aReflowInput.ComputedPhysicalPadding().left; nscoord yOffset = aReflowInput.ComputedPhysicalBorderPadding().top - aReflowInput.ComputedPhysicalPadding().top; // reflow the child ReflowOutput desiredSize(aReflowInput); ReflowChild(aKid, aPresContext, desiredSize, kidReflowInput, xOffset, yOffset, 0, aStatus); // place the child FinishReflowChild(aKid, aPresContext, desiredSize, &kidReflowInput, xOffset, yOffset, 0); // consider the overflow aParentDesiredSize.mOverflowAreas.UnionWith(desiredSize.mOverflowAreas); } nsSize nsTextControlFrame::GetXULMinSize(nsBoxLayoutState& aState) { // XXXbz why? Why not the nsBoxFrame sizes? return nsBox::GetXULMinSize(aState); } bool nsTextControlFrame::IsXULCollapsed() { // We're never collapsed in the box sense. return false; } bool nsTextControlFrame::IsLeaf() const { return true; } NS_IMETHODIMP nsTextControlFrame::ScrollOnFocusEvent::Run() { if (mFrame) { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(mFrame->GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsISelectionController* selCon = txtCtrl->GetSelectionController(); if (selCon) { mFrame->mScrollEvent.Forget(); selCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL, nsISelectionController::SELECTION_FOCUS_REGION, nsISelectionController::SCROLL_SYNCHRONOUS); } } return NS_OK; } //IMPLEMENTING NS_IFORMCONTROLFRAME void nsTextControlFrame::SetFocus(bool aOn, bool aRepaint) { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); // Revoke the previous scroll event if one exists mScrollEvent.Revoke(); // If 'dom.placeholeder.show_on_focus' preference is 'false', focusing or // blurring the frame can have an impact on the placeholder visibility. if (mUsePlaceholder) { txtCtrl->UpdatePlaceholderVisibility(true); } if (!aOn) { return; } nsISelectionController* selCon = txtCtrl->GetSelectionController(); if (!selCon) return; nsCOMPtr<nsISelection> ourSel; selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(ourSel)); if (!ourSel) return; nsIPresShell* presShell = PresContext()->GetPresShell(); RefPtr<nsCaret> caret = presShell->GetCaret(); if (!caret) return; // Scroll the current selection into view nsISelection *caretSelection = caret->GetSelection(); const bool isFocusedRightNow = ourSel == caretSelection; if (!isFocusedRightNow) { // Don't scroll the current selection if we've been focused using the mouse. uint32_t lastFocusMethod = 0; nsIDocument* doc = GetContent()->GetComposedDoc(); if (doc) { nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm) { fm->GetLastFocusMethod(doc->GetWindow(), &lastFocusMethod); } } if (!(lastFocusMethod & nsIFocusManager::FLAG_BYMOUSE)) { RefPtr<ScrollOnFocusEvent> event = new ScrollOnFocusEvent(this); nsresult rv = NS_DispatchToCurrentThread(event); if (NS_SUCCEEDED(rv)) { mScrollEvent = event; } } } // tell the caret to use our selection caret->SetSelection(ourSel); // mutual-exclusion: the selection is either controlled by the // document or by the text input/area. Clear any selection in the // document since the focus is now on our independent selection. nsCOMPtr<nsISelectionController> selcon = do_QueryInterface(presShell); nsCOMPtr<nsISelection> docSel; selcon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(docSel)); if (!docSel) return; bool isCollapsed = false; docSel->GetIsCollapsed(&isCollapsed); if (!isCollapsed) docSel->RemoveAllRanges(); } nsresult nsTextControlFrame::SetFormProperty(nsIAtom* aName, const nsAString& aValue) { if (!mIsProcessing)//some kind of lock. { mIsProcessing = true; if (nsGkAtoms::select == aName) { // Select all the text. // // XXX: This is lame, we can't call editor's SelectAll method // because that triggers AutoCopies in unix builds. // Instead, we have to call our own homegrown version // of select all which merely builds a range that selects // all of the content and adds that to the selection. nsWeakFrame weakThis = this; SelectAllOrCollapseToEndOfText(true); // NOTE: can destroy the world if (!weakThis.IsAlive()) { return NS_OK; } } mIsProcessing = false; } return NS_OK; } NS_IMETHODIMP nsTextControlFrame::GetEditor(nsIEditor **aEditor) { NS_ENSURE_ARG_POINTER(aEditor); nsresult rv = EnsureEditorInitialized(); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); *aEditor = txtCtrl->GetTextEditor(); NS_IF_ADDREF(*aEditor); return NS_OK; } nsresult nsTextControlFrame::SetSelectionInternal(nsIDOMNode *aStartNode, int32_t aStartOffset, nsIDOMNode *aEndNode, int32_t aEndOffset, nsITextControlFrame::SelectionDirection aDirection) { // Create a new range to represent the new selection. // Note that we use a new range to avoid having to do // isIncreasing checks to avoid possible errors. RefPtr<nsRange> range = new nsRange(mContent); // Be careful to use internal nsRange methods which do not check to make sure // we have access to the node. nsCOMPtr<nsINode> start = do_QueryInterface(aStartNode); nsCOMPtr<nsINode> end = do_QueryInterface(aEndNode); nsresult rv = range->Set(start, aStartOffset, end, aEndOffset); NS_ENSURE_SUCCESS(rv, rv); // Get the selection, clear it and add the new range to it! nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsISelectionController* selCon = txtCtrl->GetSelectionController(); NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE); nsCOMPtr<nsISelection> selection; selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection)); NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE); nsCOMPtr<nsISelectionPrivate> selPriv = do_QueryInterface(selection, &rv); NS_ENSURE_SUCCESS(rv, rv); nsDirection direction; if (aDirection == eNone) { // Preserve the direction direction = selPriv->GetSelectionDirection(); } else { direction = (aDirection == eBackward) ? eDirPrevious : eDirNext; } rv = selection->RemoveAllRanges(); NS_ENSURE_SUCCESS(rv, rv); rv = selection->AddRange(range); // NOTE: can destroy the world NS_ENSURE_SUCCESS(rv, rv); selPriv->SetSelectionDirection(direction); return rv; } nsresult nsTextControlFrame::ScrollSelectionIntoView() { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsISelectionController* selCon = txtCtrl->GetSelectionController(); if (selCon) { // Scroll the selection into view (see bug 231389). return selCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL, nsISelectionController::SELECTION_FOCUS_REGION, nsISelectionController::SCROLL_FIRST_ANCESTOR_ONLY); } return NS_ERROR_FAILURE; } mozilla::dom::Element* nsTextControlFrame::GetRootNodeAndInitializeEditor() { nsCOMPtr<nsIDOMElement> root; GetRootNodeAndInitializeEditor(getter_AddRefs(root)); nsCOMPtr<mozilla::dom::Element> rootElem = do_QueryInterface(root); return rootElem; } nsresult nsTextControlFrame::GetRootNodeAndInitializeEditor(nsIDOMElement **aRootElement) { NS_ENSURE_ARG_POINTER(aRootElement); nsCOMPtr<nsIEditor> editor; GetEditor(getter_AddRefs(editor)); if (!editor) return NS_OK; return editor->GetRootElement(aRootElement); } nsresult nsTextControlFrame::SelectAllOrCollapseToEndOfText(bool aSelect) { nsCOMPtr<nsIDOMElement> rootElement; nsresult rv = GetRootNodeAndInitializeEditor(getter_AddRefs(rootElement)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIContent> rootContent = do_QueryInterface(rootElement); nsCOMPtr<nsIDOMNode> rootNode(do_QueryInterface(rootElement)); NS_ENSURE_TRUE(rootNode && rootContent, NS_ERROR_FAILURE); int32_t numChildren = rootContent->GetChildCount(); if (numChildren > 0) { // We never want to place the selection after the last // br under the root node! nsIContent *child = rootContent->GetChildAt(numChildren - 1); if (child) { if (child->IsHTMLElement(nsGkAtoms::br)) --numChildren; } if (!aSelect && numChildren) { child = rootContent->GetChildAt(numChildren - 1); if (child && child->IsNodeOfType(nsINode::eTEXT)) { rootNode = do_QueryInterface(child); const nsTextFragment* fragment = child->GetText(); numChildren = fragment ? fragment->GetLength() : 0; } } } rv = SetSelectionInternal(rootNode, aSelect ? 0 : numChildren, rootNode, numChildren); NS_ENSURE_SUCCESS(rv, rv); return ScrollSelectionIntoView(); } nsresult nsTextControlFrame::SetSelectionEndPoints(int32_t aSelStart, int32_t aSelEnd, nsITextControlFrame::SelectionDirection aDirection) { NS_ASSERTION(aSelStart <= aSelEnd, "Invalid selection offsets!"); if (aSelStart > aSelEnd) return NS_ERROR_FAILURE; nsCOMPtr<nsIDOMNode> startNode, endNode; int32_t startOffset, endOffset; // Calculate the selection start point. nsresult rv = OffsetToDOMPoint(aSelStart, getter_AddRefs(startNode), &startOffset); NS_ENSURE_SUCCESS(rv, rv); if (aSelStart == aSelEnd) { // Collapsed selection, so start and end are the same! endNode = startNode; endOffset = startOffset; } else { // Selection isn't collapsed so we have to calculate // the end point too. rv = OffsetToDOMPoint(aSelEnd, getter_AddRefs(endNode), &endOffset); NS_ENSURE_SUCCESS(rv, rv); } return SetSelectionInternal(startNode, startOffset, endNode, endOffset, aDirection); } NS_IMETHODIMP nsTextControlFrame::SetSelectionRange(int32_t aSelStart, int32_t aSelEnd, nsITextControlFrame::SelectionDirection aDirection) { nsresult rv = EnsureEditorInitialized(); NS_ENSURE_SUCCESS(rv, rv); if (aSelStart > aSelEnd) { // Simulate what we'd see SetSelectionStart() was called, followed // by a SetSelectionEnd(). aSelStart = aSelEnd; } return SetSelectionEndPoints(aSelStart, aSelEnd, aDirection); } NS_IMETHODIMP nsTextControlFrame::SetSelectionStart(int32_t aSelectionStart) { nsresult rv = EnsureEditorInitialized(); NS_ENSURE_SUCCESS(rv, rv); int32_t selStart = 0, selEnd = 0; rv = GetSelectionRange(&selStart, &selEnd); NS_ENSURE_SUCCESS(rv, rv); if (aSelectionStart > selEnd) { // Collapse to the new start point. selEnd = aSelectionStart; } selStart = aSelectionStart; return SetSelectionEndPoints(selStart, selEnd); } NS_IMETHODIMP nsTextControlFrame::SetSelectionEnd(int32_t aSelectionEnd) { nsresult rv = EnsureEditorInitialized(); NS_ENSURE_SUCCESS(rv, rv); int32_t selStart = 0, selEnd = 0; rv = GetSelectionRange(&selStart, &selEnd); NS_ENSURE_SUCCESS(rv, rv); if (aSelectionEnd < selStart) { // Collapse to the new end point. selStart = aSelectionEnd; } selEnd = aSelectionEnd; return SetSelectionEndPoints(selStart, selEnd); } nsresult nsTextControlFrame::OffsetToDOMPoint(int32_t aOffset, nsIDOMNode** aResult, int32_t* aPosition) { NS_ENSURE_ARG_POINTER(aResult && aPosition); *aResult = nullptr; *aPosition = 0; nsCOMPtr<nsIDOMElement> rootElement; nsresult rv = GetRootNodeAndInitializeEditor(getter_AddRefs(rootElement)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIDOMNode> rootNode(do_QueryInterface(rootElement)); NS_ENSURE_TRUE(rootNode, NS_ERROR_FAILURE); nsCOMPtr<nsIDOMNodeList> nodeList; rv = rootNode->GetChildNodes(getter_AddRefs(nodeList)); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(nodeList, NS_ERROR_FAILURE); uint32_t length = 0; rv = nodeList->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(length <= 2, "We should have one text node and one mozBR at most"); nsCOMPtr<nsIDOMNode> firstNode; rv = nodeList->Item(0, getter_AddRefs(firstNode)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIDOMText> textNode = do_QueryInterface(firstNode); if (length == 0 || aOffset < 0) { NS_IF_ADDREF(*aResult = rootNode); *aPosition = 0; } else if (textNode) { uint32_t textLength = 0; textNode->GetLength(&textLength); if (length == 2 && uint32_t(aOffset) == textLength) { // If we're at the end of the text node and we have a trailing BR node, // set the selection on the BR node. NS_IF_ADDREF(*aResult = rootNode); *aPosition = 1; } else { // Otherwise, set the selection on the textnode itself. NS_IF_ADDREF(*aResult = firstNode); *aPosition = std::min(aOffset, int32_t(textLength)); } } else { NS_IF_ADDREF(*aResult = rootNode); *aPosition = 0; } return NS_OK; } NS_IMETHODIMP nsTextControlFrame::GetSelectionRange(int32_t* aSelectionStart, int32_t* aSelectionEnd, SelectionDirection* aDirection) { // make sure we have an editor nsresult rv = EnsureEditorInitialized(); NS_ENSURE_SUCCESS(rv, rv); if (aSelectionStart) { *aSelectionStart = 0; } if (aSelectionEnd) { *aSelectionEnd = 0; } if (aDirection) { *aDirection = eNone; } nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsISelectionController* selCon = txtCtrl->GetSelectionController(); NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE); nsCOMPtr<nsISelection> selection; rv = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection)); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE); dom::Selection* sel = selection->AsSelection(); if (aDirection) { nsDirection direction = sel->GetSelectionDirection(); if (direction == eDirNext) { *aDirection = eForward; } else if (direction == eDirPrevious) { *aDirection = eBackward; } else { NS_NOTREACHED("Invalid nsDirection enum value"); } } if (!aSelectionStart || !aSelectionEnd) { return NS_OK; } mozilla::dom::Element* root = GetRootNodeAndInitializeEditor(); NS_ENSURE_STATE(root); nsContentUtils::GetSelectionInTextControl(sel, root, *aSelectionStart, *aSelectionEnd); return NS_OK; } /////END INTERFACE IMPLEMENTATIONS ////NSIFRAME nsresult nsTextControlFrame::AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsISelectionController* selCon = txtCtrl->GetSelectionController(); const bool needEditor = nsGkAtoms::maxlength == aAttribute || nsGkAtoms::readonly == aAttribute || nsGkAtoms::disabled == aAttribute || nsGkAtoms::spellcheck == aAttribute; nsCOMPtr<nsIEditor> editor; if (needEditor) { GetEditor(getter_AddRefs(editor)); } if ((needEditor && !editor) || !selCon) { return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); } if (nsGkAtoms::maxlength == aAttribute) { int32_t maxLength; bool maxDefined = GetMaxLength(&maxLength); nsCOMPtr<nsIPlaintextEditor> textEditor = do_QueryInterface(editor); if (textEditor) { if (maxDefined) { // set the maxLength attribute textEditor->SetMaxTextLength(maxLength); // if maxLength>docLength, we need to truncate the doc content } else { // unset the maxLength attribute textEditor->SetMaxTextLength(-1); } } return NS_OK; } if (nsGkAtoms::readonly == aAttribute) { uint32_t flags; editor->GetFlags(&flags); if (AttributeExists(nsGkAtoms::readonly)) { // set readonly flags |= nsIPlaintextEditor::eEditorReadonlyMask; if (nsContentUtils::IsFocusedContent(mContent)) { selCon->SetCaretEnabled(false); } } else { // unset readonly flags &= ~(nsIPlaintextEditor::eEditorReadonlyMask); if (!(flags & nsIPlaintextEditor::eEditorDisabledMask) && nsContentUtils::IsFocusedContent(mContent)) { selCon->SetCaretEnabled(true); } } editor->SetFlags(flags); return NS_OK; } if (nsGkAtoms::disabled == aAttribute) { uint32_t flags; editor->GetFlags(&flags); int16_t displaySelection = nsISelectionController::SELECTION_OFF; const bool focused = nsContentUtils::IsFocusedContent(mContent); const bool hasAttr = AttributeExists(nsGkAtoms::disabled); if (hasAttr) { // set disabled flags |= nsIPlaintextEditor::eEditorDisabledMask; } else { // unset disabled flags &= ~(nsIPlaintextEditor::eEditorDisabledMask); displaySelection = focused ? nsISelectionController::SELECTION_ON : nsISelectionController::SELECTION_HIDDEN; } selCon->SetDisplaySelection(displaySelection); if (focused) { selCon->SetCaretEnabled(!hasAttr); } editor->SetFlags(flags); return NS_OK; } if (!mEditorHasBeenInitialized && nsGkAtoms::value == aAttribute) { UpdateValueDisplay(true); return NS_OK; } // Allow the base class to handle common attributes supported by all form // elements... return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); } nsresult nsTextControlFrame::GetText(nsString& aText) { nsresult rv = NS_OK; nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); if (IsSingleLineTextControl()) { // There will be no line breaks so we can ignore the wrap property. txtCtrl->GetTextEditorValue(aText, true); } else { nsCOMPtr<nsIDOMHTMLTextAreaElement> textArea = do_QueryInterface(mContent); if (textArea) { rv = textArea->GetValue(aText); } } return rv; } nsresult nsTextControlFrame::GetPhonetic(nsAString& aPhonetic) { aPhonetic.Truncate(0); nsCOMPtr<nsIEditor> editor; nsresult rv = GetEditor(getter_AddRefs(editor)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIEditorIMESupport> imeSupport = do_QueryInterface(editor); if (imeSupport) { nsCOMPtr<nsIPhonetic> phonetic = do_QueryInterface(imeSupport); if (phonetic) phonetic->GetPhonetic(aPhonetic); } return NS_OK; } ///END NSIFRAME OVERLOADS /////BEGIN PROTECTED METHODS bool nsTextControlFrame::GetMaxLength(int32_t* aSize) { *aSize = -1; nsGenericHTMLElement *content = nsGenericHTMLElement::FromContent(mContent); if (content) { const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::maxlength); if (attr && attr->Type() == nsAttrValue::eInteger) { *aSize = attr->GetIntegerValue(); return true; } } return false; } // END IMPLEMENTING NS_IFORMCONTROLFRAME void nsTextControlFrame::SetInitialChildList(ChildListID aListID, nsFrameList& aChildList) { nsContainerFrame::SetInitialChildList(aListID, aChildList); if (aListID != kPrincipalList) { return; } // Mark the scroll frame as being a reflow root. This will allow // incremental reflows to be initiated at the scroll frame, rather // than descending from the root frame of the frame hierarchy. if (nsIFrame* first = PrincipalChildList().FirstChild()) { first->AddStateBits(NS_FRAME_REFLOW_ROOT); nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); txtCtrl->InitializeKeyboardEventListeners(); nsPoint* contentScrollPos = Properties().Get(ContentScrollPos()); if (contentScrollPos) { // If we have a scroll pos stored to be passed to our anonymous // div, do it here! nsIStatefulFrame* statefulFrame = do_QueryFrame(first); NS_ASSERTION(statefulFrame, "unexpected type of frame for the anonymous div"); nsPresState fakePresState; fakePresState.SetScrollState(*contentScrollPos); statefulFrame->RestoreState(&fakePresState); Properties().Remove(ContentScrollPos()); delete contentScrollPos; } } } void nsTextControlFrame::SetValueChanged(bool aValueChanged) { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); if (mUsePlaceholder) { nsWeakFrame weakFrame(this); txtCtrl->UpdatePlaceholderVisibility(true); if (!weakFrame.IsAlive()) { return; } } txtCtrl->SetValueChanged(aValueChanged); } nsresult nsTextControlFrame::UpdateValueDisplay(bool aNotify, bool aBeforeEditorInit, const nsAString *aValue) { if (!IsSingleLineTextControl()) // textareas don't use this return NS_OK; nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsIContent* rootNode = txtCtrl->GetRootEditorNode(); NS_PRECONDITION(rootNode, "Must have a div content\n"); NS_PRECONDITION(!mEditorHasBeenInitialized, "Do not call this after editor has been initialized"); NS_ASSERTION(!mUsePlaceholder || txtCtrl->GetPlaceholderNode(), "A placeholder div must exist"); nsIContent *textContent = rootNode->GetChildAt(0); if (!textContent) { // Set up a textnode with our value RefPtr<nsTextNode> textNode = new nsTextNode(mContent->NodeInfo()->NodeInfoManager()); NS_ASSERTION(textNode, "Must have textcontent!\n"); rootNode->AppendChildTo(textNode, aNotify); textContent = textNode; } NS_ENSURE_TRUE(textContent, NS_ERROR_UNEXPECTED); // Get the current value of the textfield from the content. nsAutoString value; if (aValue) { value = *aValue; } else { txtCtrl->GetTextEditorValue(value, true); } // Update the display of the placeholder value if needed. // We don't need to do this if we're about to initialize the // editor, since EnsureEditorInitialized takes care of this. if (mUsePlaceholder && !aBeforeEditorInit) { nsWeakFrame weakFrame(this); txtCtrl->UpdatePlaceholderVisibility(aNotify); NS_ENSURE_STATE(weakFrame.IsAlive()); } if (aBeforeEditorInit && value.IsEmpty()) { rootNode->RemoveChildAt(0, true); return NS_OK; } if (!value.IsEmpty() && IsPasswordTextControl()) { TextEditRules::FillBufWithPWChars(&value, value.Length()); } return textContent->SetText(value, aNotify); } NS_IMETHODIMP nsTextControlFrame::GetOwnedSelectionController(nsISelectionController** aSelCon) { NS_ENSURE_ARG_POINTER(aSelCon); nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); *aSelCon = txtCtrl->GetSelectionController(); NS_IF_ADDREF(*aSelCon); return NS_OK; } nsFrameSelection* nsTextControlFrame::GetOwnedFrameSelection() { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); return txtCtrl->GetConstFrameSelection(); } NS_IMETHODIMP nsTextControlFrame::SaveState(nsPresState** aState) { NS_ENSURE_ARG_POINTER(aState); *aState = nullptr; nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsIContent* rootNode = txtCtrl->GetRootEditorNode(); if (rootNode) { // Query the nsIStatefulFrame from the HTMLScrollFrame nsIStatefulFrame* scrollStateFrame = do_QueryFrame(rootNode->GetPrimaryFrame()); if (scrollStateFrame) { return scrollStateFrame->SaveState(aState); } } return NS_OK; } NS_IMETHODIMP nsTextControlFrame::RestoreState(nsPresState* aState) { NS_ENSURE_ARG_POINTER(aState); nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element"); nsIContent* rootNode = txtCtrl->GetRootEditorNode(); if (rootNode) { // Query the nsIStatefulFrame from the HTMLScrollFrame nsIStatefulFrame* scrollStateFrame = do_QueryFrame(rootNode->GetPrimaryFrame()); if (scrollStateFrame) { return scrollStateFrame->RestoreState(aState); } } // Most likely, we don't have our anonymous content constructed yet, which // would cause us to end up here. In this case, we'll just store the scroll // pos ourselves, and forward it to the scroll frame later when it's created. Properties().Set(ContentScrollPos(), new nsPoint(aState->GetScrollPosition())); return NS_OK; } nsresult nsTextControlFrame::PeekOffset(nsPeekOffsetStruct *aPos) { return NS_ERROR_FAILURE; } void nsTextControlFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) { /* * The implementation of this method is equivalent as: * nsContainerFrame::BuildDisplayList() * with the difference that we filter-out the placeholder frame when it * should not be visible. */ DO_GLOBAL_REFLOW_COUNT_DSP("nsTextControlFrame"); nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); NS_ASSERTION(txtCtrl, "Content not a text control element!"); DisplayBorderBackgroundOutline(aBuilder, aLists); nsIFrame* kid = mFrames.FirstChild(); // Redirect all lists to the Content list so that nothing can escape, ie // opacity creating stacking contexts that then get sorted with stacking // contexts external to us. nsDisplayList* content = aLists.Content(); nsDisplayListSet set(content, content, content, content, content, content); while (kid) { // If the frame is the placeholder frame, we should only show it if the // placeholder has to be visible. if (kid->GetContent() != txtCtrl->GetPlaceholderNode() || txtCtrl->GetPlaceholderVisibility()) { BuildDisplayListForChild(aBuilder, kid, aDirtyRect, set, 0); } kid = kid->GetNextSibling(); } } mozilla::dom::Element* nsTextControlFrame::GetPseudoElement(CSSPseudoElementType aType) { if (aType == CSSPseudoElementType::placeholder) { nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent()); return txtCtrl->GetPlaceholderNode(); } return nsContainerFrame::GetPseudoElement(aType); } NS_IMETHODIMP nsTextControlFrame::EditorInitializer::Run() { if (!mFrame) { return NS_OK; } // Need to block script to avoid bug 669767. nsAutoScriptBlocker scriptBlocker; nsCOMPtr<nsIPresShell> shell = mFrame->PresContext()->GetPresShell(); bool observes = shell->ObservesNativeAnonMutationsForPrint(); shell->ObserveNativeAnonMutationsForPrint(true); // This can cause the frame to be destroyed (and call Revoke()). mFrame->EnsureEditorInitialized(); shell->ObserveNativeAnonMutationsForPrint(observes); // The frame can *still* be destroyed even though we have a scriptblocker, // bug 682684. if (!mFrame) { return NS_ERROR_FAILURE; } mFrame->FinishedInitializer(); return NS_OK; }