From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- layout/forms/nsRangeFrame.cpp | 949 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 949 insertions(+) create mode 100644 layout/forms/nsRangeFrame.cpp (limited to 'layout/forms/nsRangeFrame.cpp') diff --git a/layout/forms/nsRangeFrame.cpp b/layout/forms/nsRangeFrame.cpp new file mode 100644 index 000000000..7590da066 --- /dev/null +++ b/layout/forms/nsRangeFrame.cpp @@ -0,0 +1,949 @@ +/* -*- 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 "nsRangeFrame.h" + +#include "mozilla/EventStates.h" +#include "mozilla/TouchEvents.h" + +#include "nsContentCreatorFunctions.h" +#include "nsContentList.h" +#include "nsContentUtils.h" +#include "nsCSSPseudoElements.h" +#include "nsCSSRendering.h" +#include "nsFormControlFrame.h" +#include "nsIContent.h" +#include "nsIDocument.h" +#include "nsNameSpaceManager.h" +#include "nsIPresShell.h" +#include "nsGkAtoms.h" +#include "mozilla/dom/HTMLInputElement.h" +#include "nsPresContext.h" +#include "nsNodeInfoManager.h" +#include "nsRenderingContext.h" +#include "mozilla/dom/Element.h" +#include "mozilla/StyleSetHandle.h" +#include "mozilla/StyleSetHandleInlines.h" +#include "nsThemeConstants.h" + +#ifdef ACCESSIBILITY +#include "nsAccessibilityService.h" +#endif + +#define LONG_SIDE_TO_SHORT_SIDE_RATIO 10 + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::image; + +NS_IMPL_ISUPPORTS(nsRangeFrame::DummyTouchListener, nsIDOMEventListener) + +nsIFrame* +NS_NewRangeFrame(nsIPresShell* aPresShell, nsStyleContext* aContext) +{ + return new (aPresShell) nsRangeFrame(aContext); +} + +nsRangeFrame::nsRangeFrame(nsStyleContext* aContext) + : nsContainerFrame(aContext) +{ +} + +nsRangeFrame::~nsRangeFrame() +{ +#ifdef DEBUG + if (mOuterFocusStyle) { + mOuterFocusStyle->FrameRelease(); + } +#endif +} + +NS_IMPL_FRAMEARENA_HELPERS(nsRangeFrame) + +NS_QUERYFRAME_HEAD(nsRangeFrame) + NS_QUERYFRAME_ENTRY(nsRangeFrame) + NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator) +NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) + +void +nsRangeFrame::Init(nsIContent* aContent, + nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) +{ + // With APZ enabled, touch events may be handled directly by the APZC code + // if the APZ knows that there is no content interested in the touch event. + // The range input element *is* interested in touch events, but doesn't use + // the usual mechanism (i.e. registering an event listener) to handle touch + // input. Instead, we do it here so that the APZ finds out about it, and + // makes sure to wait for content to run handlers before handling the touch + // input itself. + if (!mDummyTouchListener) { + mDummyTouchListener = new DummyTouchListener(); + } + aContent->AddEventListener(NS_LITERAL_STRING("touchstart"), mDummyTouchListener, false); + + StyleSetHandle styleSet = PresContext()->StyleSet(); + + mOuterFocusStyle = + styleSet->ProbePseudoElementStyle(aContent->AsElement(), + CSSPseudoElementType::mozFocusOuter, + StyleContext()); + + return nsContainerFrame::Init(aContent, aParent, aPrevInFlow); +} + +void +nsRangeFrame::DestroyFrom(nsIFrame* aDestructRoot) +{ + NS_ASSERTION(!GetPrevContinuation() && !GetNextContinuation(), + "nsRangeFrame should not have continuations; if it does we " + "need to call RegUnregAccessKey only for the first."); + + mContent->RemoveEventListener(NS_LITERAL_STRING("touchstart"), mDummyTouchListener, false); + + nsFormControlFrame::RegUnRegAccessKey(static_cast(this), false); + nsContentUtils::DestroyAnonymousContent(&mTrackDiv); + nsContentUtils::DestroyAnonymousContent(&mProgressDiv); + nsContentUtils::DestroyAnonymousContent(&mThumbDiv); + nsContainerFrame::DestroyFrom(aDestructRoot); +} + +nsresult +nsRangeFrame::MakeAnonymousDiv(Element** aResult, + CSSPseudoElementType aPseudoType, + nsTArray& aElements) +{ + nsCOMPtr doc = mContent->GetComposedDoc(); + RefPtr resultElement = doc->CreateHTMLElement(nsGkAtoms::div); + + // Associate the pseudo-element with the anonymous child. + RefPtr newStyleContext = + PresContext()->StyleSet()->ResolvePseudoElementStyle(mContent->AsElement(), + aPseudoType, + StyleContext(), + resultElement); + + if (!aElements.AppendElement(ContentInfo(resultElement, newStyleContext))) { + return NS_ERROR_OUT_OF_MEMORY; + } + + resultElement.forget(aResult); + return NS_OK; +} + +nsresult +nsRangeFrame::CreateAnonymousContent(nsTArray& aElements) +{ + nsresult rv; + + // Create the ::-moz-range-track pseuto-element (a div): + rv = MakeAnonymousDiv(getter_AddRefs(mTrackDiv), + CSSPseudoElementType::mozRangeTrack, + aElements); + NS_ENSURE_SUCCESS(rv, rv); + + // Create the ::-moz-range-progress pseudo-element (a div): + rv = MakeAnonymousDiv(getter_AddRefs(mProgressDiv), + CSSPseudoElementType::mozRangeProgress, + aElements); + NS_ENSURE_SUCCESS(rv, rv); + + // Create the ::-moz-range-thumb pseudo-element (a div): + rv = MakeAnonymousDiv(getter_AddRefs(mThumbDiv), + CSSPseudoElementType::mozRangeThumb, + aElements); + return rv; +} + +void +nsRangeFrame::AppendAnonymousContentTo(nsTArray& aElements, + uint32_t aFilter) +{ + if (mTrackDiv) { + aElements.AppendElement(mTrackDiv); + } + + if (mProgressDiv) { + aElements.AppendElement(mProgressDiv); + } + + if (mThumbDiv) { + aElements.AppendElement(mThumbDiv); + } +} + +class nsDisplayRangeFocusRing : public nsDisplayItem +{ +public: + nsDisplayRangeFocusRing(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame) + : nsDisplayItem(aBuilder, aFrame) { + MOZ_COUNT_CTOR(nsDisplayRangeFocusRing); + } +#ifdef NS_BUILD_REFCNT_LOGGING + virtual ~nsDisplayRangeFocusRing() { + MOZ_COUNT_DTOR(nsDisplayRangeFocusRing); + } +#endif + + nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override; + void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder, + const nsDisplayItemGeometry* aGeometry, + nsRegion *aInvalidRegion) override; + virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override; + virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override; + NS_DISPLAY_DECL_NAME("RangeFocusRing", TYPE_RANGE_FOCUS_RING) +}; + +nsDisplayItemGeometry* +nsDisplayRangeFocusRing::AllocateGeometry(nsDisplayListBuilder* aBuilder) +{ + return new nsDisplayItemGenericImageGeometry(this, aBuilder); +} + +void +nsDisplayRangeFocusRing::ComputeInvalidationRegion( + nsDisplayListBuilder* aBuilder, + const nsDisplayItemGeometry* aGeometry, + nsRegion* aInvalidRegion) +{ + auto geometry = + static_cast(aGeometry); + + if (aBuilder->ShouldSyncDecodeImages() && + geometry->ShouldInvalidateToSyncDecodeImages()) { + bool snap; + aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap)); + } + + nsDisplayItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion); +} + +nsRect +nsDisplayRangeFocusRing::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) +{ + *aSnap = false; + nsRect rect(ToReferenceFrame(), Frame()->GetSize()); + + // We want to paint as if specifying a border for ::-moz-focus-outer + // specifies an outline for our frame, so inflate by the border widths: + nsStyleContext* styleContext = + static_cast(mFrame)->mOuterFocusStyle; + MOZ_ASSERT(styleContext, "We only exist if mOuterFocusStyle is non-null"); + rect.Inflate(styleContext->StyleBorder()->GetComputedBorder()); + + return rect; +} + +void +nsDisplayRangeFocusRing::Paint(nsDisplayListBuilder* aBuilder, + nsRenderingContext* aCtx) +{ + bool unused; + nsStyleContext* styleContext = + static_cast(mFrame)->mOuterFocusStyle; + MOZ_ASSERT(styleContext, "We only exist if mOuterFocusStyle is non-null"); + + PaintBorderFlags flags = aBuilder->ShouldSyncDecodeImages() + ? PaintBorderFlags::SYNC_DECODE_IMAGES + : PaintBorderFlags(); + + DrawResult result = + nsCSSRendering::PaintBorder(mFrame->PresContext(), *aCtx, mFrame, + mVisibleRect, GetBounds(aBuilder, &unused), + styleContext, flags); + + nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result); +} + +void +nsRangeFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsRect& aDirtyRect, + const nsDisplayListSet& aLists) +{ + if (IsThemed()) { + DisplayBorderBackgroundOutline(aBuilder, aLists); + // Only create items for the thumb. Specifically, we do not want + // the track to paint, since *our* background is used to paint + // the track, and we don't want the unthemed track painting over + // the top of the themed track. + // This logic is copied from + // nsContainerFrame::BuildDisplayListForNonBlockChildren as + // called by BuildDisplayListForInline. + nsIFrame* thumb = mThumbDiv->GetPrimaryFrame(); + if (thumb) { + nsDisplayListSet set(aLists, aLists.Content()); + BuildDisplayListForChild(aBuilder, thumb, aDirtyRect, set, DISPLAY_CHILD_INLINE); + } + } else { + BuildDisplayListForInline(aBuilder, aDirtyRect, aLists); + } + + // Draw a focus outline if appropriate: + + if (!aBuilder->IsForPainting() || + !IsVisibleForPainting(aBuilder)) { + // we don't want the focus ring item for hit-testing or if the item isn't + // in the area being [re]painted + return; + } + + EventStates eventStates = mContent->AsElement()->State(); + if (eventStates.HasState(NS_EVENT_STATE_DISABLED) || + !eventStates.HasState(NS_EVENT_STATE_FOCUSRING)) { + return; // can't have focus or doesn't match :-moz-focusring + } + + if (!mOuterFocusStyle || + !mOuterFocusStyle->StyleBorder()->HasBorder()) { + // no ::-moz-focus-outer specified border (how style specifies a focus ring + // for range) + return; + } + + const nsStyleDisplay *disp = StyleDisplay(); + if (IsThemed(disp) && + PresContext()->GetTheme()->ThemeDrawsFocusForWidget(disp->mAppearance)) { + return; // the native theme displays its own visual indication of focus + } + + aLists.Content()->AppendNewToTop( + new (aBuilder) nsDisplayRangeFocusRing(aBuilder, this)); +} + +void +nsRangeFrame::Reflow(nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) +{ + MarkInReflow(); + DO_GLOBAL_REFLOW_COUNT("nsRangeFrame"); + DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus); + + NS_ASSERTION(mTrackDiv, "::-moz-range-track div must exist!"); + NS_ASSERTION(mProgressDiv, "::-moz-range-progress div must exist!"); + NS_ASSERTION(mThumbDiv, "::-moz-range-thumb div must exist!"); + NS_ASSERTION(!GetPrevContinuation() && !GetNextContinuation(), + "nsRangeFrame should not have continuations; if it does we " + "need to call RegUnregAccessKey only for the first."); + + if (mState & NS_FRAME_FIRST_REFLOW) { + nsFormControlFrame::RegUnRegAccessKey(this, true); + } + + WritingMode wm = aReflowInput.GetWritingMode(); + nscoord computedBSize = aReflowInput.ComputedBSize(); + if (computedBSize == NS_AUTOHEIGHT) { + computedBSize = 0; + } + LogicalSize + finalSize(wm, + aReflowInput.ComputedISize() + + aReflowInput.ComputedLogicalBorderPadding().IStartEnd(wm), + computedBSize + + aReflowInput.ComputedLogicalBorderPadding().BStartEnd(wm)); + aDesiredSize.SetSize(wm, finalSize); + + ReflowAnonymousContent(aPresContext, aDesiredSize, aReflowInput); + + aDesiredSize.SetOverflowAreasToDesiredBounds(); + + nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame(); + if (trackFrame) { + ConsiderChildOverflow(aDesiredSize.mOverflowAreas, trackFrame); + } + + nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame(); + if (rangeProgressFrame) { + ConsiderChildOverflow(aDesiredSize.mOverflowAreas, rangeProgressFrame); + } + + nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame(); + if (thumbFrame) { + ConsiderChildOverflow(aDesiredSize.mOverflowAreas, thumbFrame); + } + + FinishAndStoreOverflow(&aDesiredSize); + + aStatus = NS_FRAME_COMPLETE; + + NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize); +} + +void +nsRangeFrame::ReflowAnonymousContent(nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput) +{ + // The width/height of our content box, which is the available width/height + // for our anonymous content: + nscoord rangeFrameContentBoxWidth = aReflowInput.ComputedWidth(); + nscoord rangeFrameContentBoxHeight = aReflowInput.ComputedHeight(); + if (rangeFrameContentBoxHeight == NS_AUTOHEIGHT) { + rangeFrameContentBoxHeight = 0; + } + + nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame(); + + if (trackFrame) { // display:none? + + // Position the track: + // The idea here is that we allow content authors to style the width, + // height, border and padding of the track, but we ignore margin and + // positioning properties and do the positioning ourself to keep the center + // of the track's border box on the center of the nsRangeFrame's content + // box. + + WritingMode wm = trackFrame->GetWritingMode(); + LogicalSize availSize = aReflowInput.ComputedSize(wm); + availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; + ReflowInput trackReflowInput(aPresContext, aReflowInput, + trackFrame, availSize); + + // Find the x/y position of the track frame such that it will be positioned + // as described above. These coordinates are with respect to the + // nsRangeFrame's border-box. + nscoord trackX = rangeFrameContentBoxWidth / 2; + nscoord trackY = rangeFrameContentBoxHeight / 2; + + // Account for the track's border and padding (we ignore its margin): + trackX -= trackReflowInput.ComputedPhysicalBorderPadding().left + + trackReflowInput.ComputedWidth() / 2; + trackY -= trackReflowInput.ComputedPhysicalBorderPadding().top + + trackReflowInput.ComputedHeight() / 2; + + // Make relative to our border box instead of our content box: + trackX += aReflowInput.ComputedPhysicalBorderPadding().left; + trackY += aReflowInput.ComputedPhysicalBorderPadding().top; + + nsReflowStatus frameStatus; + ReflowOutput trackDesiredSize(aReflowInput); + ReflowChild(trackFrame, aPresContext, trackDesiredSize, + trackReflowInput, trackX, trackY, 0, frameStatus); + MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus), + "We gave our child unconstrained height, so it should be complete"); + FinishReflowChild(trackFrame, aPresContext, trackDesiredSize, + &trackReflowInput, trackX, trackY, 0); + } + + nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame(); + + if (thumbFrame) { // display:none? + WritingMode wm = thumbFrame->GetWritingMode(); + LogicalSize availSize = aReflowInput.ComputedSize(wm); + availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; + ReflowInput thumbReflowInput(aPresContext, aReflowInput, + thumbFrame, availSize); + + // Where we position the thumb depends on its size, so we first reflow + // the thumb at {0,0} to obtain its size, then position it afterwards. + + nsReflowStatus frameStatus; + ReflowOutput thumbDesiredSize(aReflowInput); + ReflowChild(thumbFrame, aPresContext, thumbDesiredSize, + thumbReflowInput, 0, 0, 0, frameStatus); + MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus), + "We gave our child unconstrained height, so it should be complete"); + FinishReflowChild(thumbFrame, aPresContext, thumbDesiredSize, + &thumbReflowInput, 0, 0, 0); + DoUpdateThumbPosition(thumbFrame, nsSize(aDesiredSize.Width(), + aDesiredSize.Height())); + } + + nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame(); + + if (rangeProgressFrame) { // display:none? + WritingMode wm = rangeProgressFrame->GetWritingMode(); + LogicalSize availSize = aReflowInput.ComputedSize(wm); + availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; + ReflowInput progressReflowInput(aPresContext, aReflowInput, + rangeProgressFrame, availSize); + + // We first reflow the range-progress frame at {0,0} to obtain its + // unadjusted dimensions, then we adjust it to so that the appropriate edge + // ends at the thumb. + + nsReflowStatus frameStatus; + ReflowOutput progressDesiredSize(aReflowInput); + ReflowChild(rangeProgressFrame, aPresContext, + progressDesiredSize, progressReflowInput, 0, 0, + 0, frameStatus); + MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus), + "We gave our child unconstrained height, so it should be complete"); + FinishReflowChild(rangeProgressFrame, aPresContext, + progressDesiredSize, &progressReflowInput, 0, 0, 0); + DoUpdateRangeProgressFrame(rangeProgressFrame, nsSize(aDesiredSize.Width(), + aDesiredSize.Height())); + } +} + +#ifdef ACCESSIBILITY +a11y::AccType +nsRangeFrame::AccessibleType() +{ + return a11y::eHTMLRangeType; +} +#endif + +double +nsRangeFrame::GetValueAsFractionOfRange() +{ + MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast"); + dom::HTMLInputElement* input = static_cast(mContent); + + MOZ_ASSERT(input->GetType() == NS_FORM_INPUT_RANGE); + + Decimal value = input->GetValueAsDecimal(); + Decimal minimum = input->GetMinimum(); + Decimal maximum = input->GetMaximum(); + + MOZ_ASSERT(value.isFinite() && minimum.isFinite() && maximum.isFinite(), + "type=range should have a default maximum/minimum"); + + if (maximum <= minimum) { + MOZ_ASSERT(value == minimum, "Unsanitized value"); + return 0.0; + } + + MOZ_ASSERT(value >= minimum && value <= maximum, "Unsanitized value"); + + return ((value - minimum) / (maximum - minimum)).toDouble(); +} + +Decimal +nsRangeFrame::GetValueAtEventPoint(WidgetGUIEvent* aEvent) +{ + MOZ_ASSERT(aEvent->mClass == eMouseEventClass || + aEvent->mClass == eTouchEventClass, + "Unexpected event type - aEvent->mRefPoint may be meaningless"); + + MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast"); + dom::HTMLInputElement* input = static_cast(mContent); + + MOZ_ASSERT(input->GetType() == NS_FORM_INPUT_RANGE); + + Decimal minimum = input->GetMinimum(); + Decimal maximum = input->GetMaximum(); + MOZ_ASSERT(minimum.isFinite() && maximum.isFinite(), + "type=range should have a default maximum/minimum"); + if (maximum <= minimum) { + return minimum; + } + Decimal range = maximum - minimum; + + LayoutDeviceIntPoint absPoint; + if (aEvent->mClass == eTouchEventClass) { + MOZ_ASSERT(aEvent->AsTouchEvent()->mTouches.Length() == 1, + "Unexpected number of mTouches"); + absPoint = aEvent->AsTouchEvent()->mTouches[0]->mRefPoint; + } else { + absPoint = aEvent->mRefPoint; + } + nsPoint point = + nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, absPoint, this); + + if (point == nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)) { + // We don't want to change the current value for this error state. + return static_cast(mContent)->GetValueAsDecimal(); + } + + nsRect rangeContentRect = GetContentRectRelativeToSelf(); + nsSize thumbSize; + + if (IsThemed()) { + // We need to get the size of the thumb from the theme. + nsPresContext *presContext = PresContext(); + bool notUsedCanOverride; + LayoutDeviceIntSize size; + presContext->GetTheme()-> + GetMinimumWidgetSize(presContext, this, NS_THEME_RANGE_THUMB, &size, + ¬UsedCanOverride); + thumbSize.width = presContext->DevPixelsToAppUnits(size.width); + thumbSize.height = presContext->DevPixelsToAppUnits(size.height); + MOZ_ASSERT(thumbSize.width > 0 && thumbSize.height > 0); + } else { + nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame(); + if (thumbFrame) { // diplay:none? + thumbSize = thumbFrame->GetSize(); + } + } + + Decimal fraction; + if (IsHorizontal()) { + nscoord traversableDistance = rangeContentRect.width - thumbSize.width; + if (traversableDistance <= 0) { + return minimum; + } + nscoord posAtStart = rangeContentRect.x + thumbSize.width/2; + nscoord posAtEnd = posAtStart + traversableDistance; + nscoord posOfPoint = mozilla::clamped(point.x, posAtStart, posAtEnd); + fraction = Decimal(posOfPoint - posAtStart) / Decimal(traversableDistance); + if (IsRightToLeft()) { + fraction = Decimal(1) - fraction; + } + } else { + nscoord traversableDistance = rangeContentRect.height - thumbSize.height; + if (traversableDistance <= 0) { + return minimum; + } + nscoord posAtStart = rangeContentRect.y + thumbSize.height/2; + nscoord posAtEnd = posAtStart + traversableDistance; + nscoord posOfPoint = mozilla::clamped(point.y, posAtStart, posAtEnd); + // For a vertical range, the top (posAtStart) is the highest value, so we + // subtract the fraction from 1.0 to get that polarity correct. + fraction = Decimal(1) - Decimal(posOfPoint - posAtStart) / Decimal(traversableDistance); + } + + MOZ_ASSERT(fraction >= Decimal(0) && fraction <= Decimal(1)); + return minimum + fraction * range; +} + +void +nsRangeFrame::UpdateForValueChange() +{ + if (NS_SUBTREE_DIRTY(this)) { + return; // we're going to be updated when we reflow + } + nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame(); + nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame(); + if (!rangeProgressFrame && !thumbFrame) { + return; // diplay:none? + } + if (rangeProgressFrame) { + DoUpdateRangeProgressFrame(rangeProgressFrame, GetSize()); + } + if (thumbFrame) { + DoUpdateThumbPosition(thumbFrame, GetSize()); + } + if (IsThemed()) { + // We don't know the exact dimensions or location of the thumb when native + // theming is applied, so we just repaint the entire range. + InvalidateFrame(); + } + +#ifdef ACCESSIBILITY + nsAccessibilityService* accService = nsIPresShell::AccService(); + if (accService) { + accService->RangeValueChanged(PresContext()->PresShell(), mContent); + } +#endif + + SchedulePaint(); +} + +void +nsRangeFrame::DoUpdateThumbPosition(nsIFrame* aThumbFrame, + const nsSize& aRangeSize) +{ + MOZ_ASSERT(aThumbFrame); + + // The idea here is that we want to position the thumb so that the center + // of the thumb is on an imaginary line drawn from the middle of one edge + // of the range frame's content box to the middle of the opposite edge of + // its content box (the opposite edges being the left/right edge if the + // range is horizontal, or else the top/bottom edges if the range is + // vertical). How far along this line the center of the thumb is placed + // depends on the value of the range. + + nsMargin borderAndPadding = GetUsedBorderAndPadding(); + nsPoint newPosition(borderAndPadding.left, borderAndPadding.top); + + nsSize rangeContentBoxSize(aRangeSize); + rangeContentBoxSize.width -= borderAndPadding.LeftRight(); + rangeContentBoxSize.height -= borderAndPadding.TopBottom(); + + nsSize thumbSize = aThumbFrame->GetSize(); + double fraction = GetValueAsFractionOfRange(); + MOZ_ASSERT(fraction >= 0.0 && fraction <= 1.0); + + if (IsHorizontal()) { + if (thumbSize.width < rangeContentBoxSize.width) { + nscoord traversableDistance = + rangeContentBoxSize.width - thumbSize.width; + if (IsRightToLeft()) { + newPosition.x += NSToCoordRound((1.0 - fraction) * traversableDistance); + } else { + newPosition.x += NSToCoordRound(fraction * traversableDistance); + } + newPosition.y += (rangeContentBoxSize.height - thumbSize.height)/2; + } + } else { + if (thumbSize.height < rangeContentBoxSize.height) { + nscoord traversableDistance = + rangeContentBoxSize.height - thumbSize.height; + newPosition.x += (rangeContentBoxSize.width - thumbSize.width)/2; + newPosition.y += NSToCoordRound((1.0 - fraction) * traversableDistance); + } + } + aThumbFrame->SetPosition(newPosition); +} + +void +nsRangeFrame::DoUpdateRangeProgressFrame(nsIFrame* aRangeProgressFrame, + const nsSize& aRangeSize) +{ + MOZ_ASSERT(aRangeProgressFrame); + + // The idea here is that we want to position the ::-moz-range-progress + // pseudo-element so that the center line running along its length is on the + // corresponding center line of the nsRangeFrame's content box. In the other + // dimension, we align the "start" edge of the ::-moz-range-progress + // pseudo-element's border-box with the corresponding edge of the + // nsRangeFrame's content box, and we size the progress element's border-box + // to have a length of GetValueAsFractionOfRange() times the nsRangeFrame's + // content-box size. + + nsMargin borderAndPadding = GetUsedBorderAndPadding(); + nsSize progSize = aRangeProgressFrame->GetSize(); + nsRect progRect(borderAndPadding.left, borderAndPadding.top, + progSize.width, progSize.height); + + nsSize rangeContentBoxSize(aRangeSize); + rangeContentBoxSize.width -= borderAndPadding.LeftRight(); + rangeContentBoxSize.height -= borderAndPadding.TopBottom(); + + double fraction = GetValueAsFractionOfRange(); + MOZ_ASSERT(fraction >= 0.0 && fraction <= 1.0); + + if (IsHorizontal()) { + nscoord progLength = NSToCoordRound(fraction * rangeContentBoxSize.width); + if (IsRightToLeft()) { + progRect.x += rangeContentBoxSize.width - progLength; + } + progRect.y += (rangeContentBoxSize.height - progSize.height)/2; + progRect.width = progLength; + } else { + nscoord progLength = NSToCoordRound(fraction * rangeContentBoxSize.height); + progRect.x += (rangeContentBoxSize.width - progSize.width)/2; + progRect.y += rangeContentBoxSize.height - progLength; + progRect.height = progLength; + } + aRangeProgressFrame->SetRect(progRect); +} + +nsresult +nsRangeFrame::AttributeChanged(int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType) +{ + NS_ASSERTION(mTrackDiv, "The track div must exist!"); + NS_ASSERTION(mThumbDiv, "The thumb div must exist!"); + + if (aNameSpaceID == kNameSpaceID_None) { + if (aAttribute == nsGkAtoms::value || + aAttribute == nsGkAtoms::min || + aAttribute == nsGkAtoms::max || + aAttribute == nsGkAtoms::step) { + // We want to update the position of the thumb, except in one special + // case: If the value attribute is being set, it is possible that we are + // in the middle of a type change away from type=range, under the + // SetAttr(..., nsGkAtoms::value, ...) call in HTMLInputElement:: + // HandleTypeChange. In that case the HTMLInputElement's type will + // already have changed, and if we call UpdateForValueChange() + // we'll fail the asserts under that call that check the type of our + // HTMLInputElement. Given that we're changing away from being a range + // and this frame will shortly be destroyed, there's no point in calling + // UpdateForValueChange() anyway. + MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast"); + bool typeIsRange = static_cast(mContent)->GetType() == + NS_FORM_INPUT_RANGE; + // If script changed the 's type before setting these attributes + // then we don't need to do anything since we are going to be reframed. + if (typeIsRange) { + UpdateForValueChange(); + } + } else if (aAttribute == nsGkAtoms::orient) { + PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eResize, + NS_FRAME_IS_DIRTY); + } + } + + return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); +} + +LogicalSize +nsRangeFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext, + WritingMode aWM, + const LogicalSize& aCBSize, + nscoord aAvailableISize, + const LogicalSize& aMargin, + const LogicalSize& aBorder, + const LogicalSize& aPadding, + ComputeSizeFlags aFlags) +{ + nscoord oneEm = NSToCoordRound(StyleFont()->mFont.size * + nsLayoutUtils::FontSizeInflationFor(this)); // 1em + + bool isInlineOriented = IsInlineOriented(); + + const WritingMode wm = GetWritingMode(); + LogicalSize autoSize(wm); + + // nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being + // given too small a size when we're natively themed. If we're themed, we set + // our "thickness" dimension to zero below and rely on that + // GetMinimumWidgetSize check to correct that dimension to the natural + // thickness of a slider in the current theme. + + if (isInlineOriented) { + autoSize.ISize(wm) = LONG_SIDE_TO_SHORT_SIDE_RATIO * oneEm; + autoSize.BSize(wm) = IsThemed() ? 0 : oneEm; + } else { + autoSize.ISize(wm) = IsThemed() ? 0 : oneEm; + autoSize.BSize(wm) = LONG_SIDE_TO_SHORT_SIDE_RATIO * oneEm; + } + + return autoSize.ConvertTo(aWM, wm); +} + +nscoord +nsRangeFrame::GetMinISize(nsRenderingContext *aRenderingContext) +{ + // nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being + // given too small a size when we're natively themed. If we aren't native + // themed, we don't mind how small we're sized. + return nscoord(0); +} + +nscoord +nsRangeFrame::GetPrefISize(nsRenderingContext *aRenderingContext) +{ + bool isInline = IsInlineOriented(); + + if (!isInline && IsThemed()) { + // nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being + // given too small a size when we're natively themed. We return zero and + // depend on that correction to get our "natural" width when we're a + // vertical slider. + return 0; + } + + nscoord prefISize = NSToCoordRound(StyleFont()->mFont.size * + nsLayoutUtils::FontSizeInflationFor(this)); // 1em + + if (isInline) { + prefISize *= LONG_SIDE_TO_SHORT_SIDE_RATIO; + } + + return prefISize; +} + +bool +nsRangeFrame::IsHorizontal() const +{ + dom::HTMLInputElement* element = + static_cast(mContent); + return element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient, + nsGkAtoms::horizontal, eCaseMatters) || + (!element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient, + nsGkAtoms::vertical, eCaseMatters) && + GetWritingMode().IsVertical() == + element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient, + nsGkAtoms::block, eCaseMatters)); +} + +double +nsRangeFrame::GetMin() const +{ + return static_cast(mContent)->GetMinimum().toDouble(); +} + +double +nsRangeFrame::GetMax() const +{ + return static_cast(mContent)->GetMaximum().toDouble(); +} + +double +nsRangeFrame::GetValue() const +{ + return static_cast(mContent)->GetValueAsDecimal().toDouble(); +} + +nsIAtom* +nsRangeFrame::GetType() const +{ + return nsGkAtoms::rangeFrame; +} + +#define STYLES_DISABLING_NATIVE_THEMING \ + NS_AUTHOR_SPECIFIED_BACKGROUND | \ + NS_AUTHOR_SPECIFIED_PADDING | \ + NS_AUTHOR_SPECIFIED_BORDER + +bool +nsRangeFrame::ShouldUseNativeStyle() const +{ + nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame(); + nsIFrame* progressFrame = mProgressDiv->GetPrimaryFrame(); + nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame(); + + return (StyleDisplay()->mAppearance == NS_THEME_RANGE) && + !PresContext()->HasAuthorSpecifiedRules(this, + (NS_AUTHOR_SPECIFIED_BORDER | + NS_AUTHOR_SPECIFIED_BACKGROUND)) && + trackFrame && + !PresContext()->HasAuthorSpecifiedRules(trackFrame, + STYLES_DISABLING_NATIVE_THEMING) && + progressFrame && + !PresContext()->HasAuthorSpecifiedRules(progressFrame, + STYLES_DISABLING_NATIVE_THEMING) && + thumbFrame && + !PresContext()->HasAuthorSpecifiedRules(thumbFrame, + STYLES_DISABLING_NATIVE_THEMING); +} + +Element* +nsRangeFrame::GetPseudoElement(CSSPseudoElementType aType) +{ + if (aType == CSSPseudoElementType::mozRangeTrack) { + return mTrackDiv; + } + + if (aType == CSSPseudoElementType::mozRangeThumb) { + return mThumbDiv; + } + + if (aType == CSSPseudoElementType::mozRangeProgress) { + return mProgressDiv; + } + + return nsContainerFrame::GetPseudoElement(aType); +} + +nsStyleContext* +nsRangeFrame::GetAdditionalStyleContext(int32_t aIndex) const +{ + // We only implement this so that SetAdditionalStyleContext will be + // called if style changes that would change the -moz-focus-outer + // pseudo-element have occurred. + if (aIndex != 0) { + return nullptr; + } + return mOuterFocusStyle; +} + +void +nsRangeFrame::SetAdditionalStyleContext(int32_t aIndex, + nsStyleContext* aStyleContext) +{ + MOZ_ASSERT(aIndex == 0, + "GetAdditionalStyleContext is handling other indexes?"); + +#ifdef DEBUG + if (mOuterFocusStyle) { + mOuterFocusStyle->FrameRelease(); + } +#endif + + // The -moz-focus-outer pseudo-element's style has changed. + mOuterFocusStyle = aStyleContext; + +#ifdef DEBUG + if (mOuterFocusStyle) { + mOuterFocusStyle->FrameAddRef(); + } +#endif +} -- cgit v1.2.3