mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
948 lines
33 KiB
C++
948 lines
33 KiB
C++
/* -*- 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 "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 "nsStyleSet.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);
|
|
|
|
nsStyleSet *styleSet = PresContext()->StyleSet();
|
|
|
|
mOuterFocusStyle =
|
|
styleSet->ProbePseudoElementStyle(aContent->AsElement(),
|
|
nsCSSPseudoElements::ePseudo_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<nsIFrame*>(this), false);
|
|
nsContentUtils::DestroyAnonymousContent(&mTrackDiv);
|
|
nsContentUtils::DestroyAnonymousContent(&mProgressDiv);
|
|
nsContentUtils::DestroyAnonymousContent(&mThumbDiv);
|
|
nsContainerFrame::DestroyFrom(aDestructRoot);
|
|
}
|
|
|
|
nsresult
|
|
nsRangeFrame::MakeAnonymousDiv(Element** aResult,
|
|
nsCSSPseudoElements::Type aPseudoType,
|
|
nsTArray<ContentInfo>& aElements)
|
|
{
|
|
nsCOMPtr<nsIDocument> doc = mContent->GetComposedDoc();
|
|
RefPtr<Element> resultElement = doc->CreateHTMLElement(nsGkAtoms::div);
|
|
|
|
// Associate the pseudo-element with the anonymous child.
|
|
RefPtr<nsStyleContext> 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<ContentInfo>& aElements)
|
|
{
|
|
nsresult rv;
|
|
|
|
// Create the ::-moz-range-track pseuto-element (a div):
|
|
rv = MakeAnonymousDiv(getter_AddRefs(mTrackDiv),
|
|
nsCSSPseudoElements::ePseudo_mozRangeTrack,
|
|
aElements);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Create the ::-moz-range-progress pseudo-element (a div):
|
|
rv = MakeAnonymousDiv(getter_AddRefs(mProgressDiv),
|
|
nsCSSPseudoElements::ePseudo_mozRangeProgress,
|
|
aElements);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Create the ::-moz-range-thumb pseudo-element (a div):
|
|
rv = MakeAnonymousDiv(getter_AddRefs(mThumbDiv),
|
|
nsCSSPseudoElements::ePseudo_mozRangeThumb,
|
|
aElements);
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsRangeFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& 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<const nsDisplayItemGenericImageGeometry*>(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<nsRangeFrame*>(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<nsRangeFrame*>(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,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsRangeFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowState, 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 = aReflowState.GetWritingMode();
|
|
nscoord computedBSize = aReflowState.ComputedBSize();
|
|
if (computedBSize == NS_AUTOHEIGHT) {
|
|
computedBSize = 0;
|
|
}
|
|
LogicalSize
|
|
finalSize(wm,
|
|
aReflowState.ComputedISize() +
|
|
aReflowState.ComputedLogicalBorderPadding().IStartEnd(wm),
|
|
computedBSize +
|
|
aReflowState.ComputedLogicalBorderPadding().BStartEnd(wm));
|
|
aDesiredSize.SetSize(wm, finalSize);
|
|
|
|
ReflowAnonymousContent(aPresContext, aDesiredSize, aReflowState);
|
|
|
|
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, aReflowState, aDesiredSize);
|
|
}
|
|
|
|
void
|
|
nsRangeFrame::ReflowAnonymousContent(nsPresContext* aPresContext,
|
|
nsHTMLReflowMetrics& aDesiredSize,
|
|
const nsHTMLReflowState& aReflowState)
|
|
{
|
|
// The width/height of our content box, which is the available width/height
|
|
// for our anonymous content:
|
|
nscoord rangeFrameContentBoxWidth = aReflowState.ComputedWidth();
|
|
nscoord rangeFrameContentBoxHeight = aReflowState.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 = aReflowState.ComputedSize(wm);
|
|
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
|
|
nsHTMLReflowState trackReflowState(aPresContext, aReflowState,
|
|
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 -= trackReflowState.ComputedPhysicalBorderPadding().left +
|
|
trackReflowState.ComputedWidth() / 2;
|
|
trackY -= trackReflowState.ComputedPhysicalBorderPadding().top +
|
|
trackReflowState.ComputedHeight() / 2;
|
|
|
|
// Make relative to our border box instead of our content box:
|
|
trackX += aReflowState.ComputedPhysicalBorderPadding().left;
|
|
trackY += aReflowState.ComputedPhysicalBorderPadding().top;
|
|
|
|
nsReflowStatus frameStatus;
|
|
nsHTMLReflowMetrics trackDesiredSize(aReflowState);
|
|
ReflowChild(trackFrame, aPresContext, trackDesiredSize,
|
|
trackReflowState, 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,
|
|
&trackReflowState, trackX, trackY, 0);
|
|
}
|
|
|
|
nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
|
|
|
|
if (thumbFrame) { // display:none?
|
|
WritingMode wm = thumbFrame->GetWritingMode();
|
|
LogicalSize availSize = aReflowState.ComputedSize(wm);
|
|
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
|
|
nsHTMLReflowState thumbReflowState(aPresContext, aReflowState,
|
|
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;
|
|
nsHTMLReflowMetrics thumbDesiredSize(aReflowState);
|
|
ReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
|
|
thumbReflowState, 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,
|
|
&thumbReflowState, 0, 0, 0);
|
|
DoUpdateThumbPosition(thumbFrame, nsSize(aDesiredSize.Width(),
|
|
aDesiredSize.Height()));
|
|
}
|
|
|
|
nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
|
|
|
|
if (rangeProgressFrame) { // display:none?
|
|
WritingMode wm = rangeProgressFrame->GetWritingMode();
|
|
LogicalSize availSize = aReflowState.ComputedSize(wm);
|
|
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
|
|
nsHTMLReflowState progressReflowState(aPresContext, aReflowState,
|
|
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;
|
|
nsHTMLReflowMetrics progressDesiredSize(aReflowState);
|
|
ReflowChild(rangeProgressFrame, aPresContext,
|
|
progressDesiredSize, progressReflowState, 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, &progressReflowState, 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<dom::HTMLInputElement*>(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->refPoint may be meaningless");
|
|
|
|
MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast");
|
|
dom::HTMLInputElement* input = static_cast<dom::HTMLInputElement*>(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()->touches.Length() == 1,
|
|
"Unexpected number of touches");
|
|
absPoint = aEvent->AsTouchEvent()->touches[0]->mRefPoint;
|
|
} else {
|
|
absPoint = aEvent->refPoint;
|
|
}
|
|
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<dom::HTMLInputElement*>(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<dom::HTMLInputElement*>(mContent)->GetType() ==
|
|
NS_FORM_INPUT_RANGE;
|
|
// If script changed the <input>'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,
|
|
bool aShrinkWrap)
|
|
{
|
|
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<dom::HTMLInputElement*>(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<dom::HTMLInputElement*>(mContent)->GetMinimum().toDouble();
|
|
}
|
|
|
|
double
|
|
nsRangeFrame::GetMax() const
|
|
{
|
|
return static_cast<dom::HTMLInputElement*>(mContent)->GetMaximum().toDouble();
|
|
}
|
|
|
|
double
|
|
nsRangeFrame::GetValue() const
|
|
{
|
|
return static_cast<dom::HTMLInputElement*>(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(nsCSSPseudoElements::Type aType)
|
|
{
|
|
if (aType == nsCSSPseudoElements::ePseudo_mozRangeTrack) {
|
|
return mTrackDiv;
|
|
}
|
|
|
|
if (aType == nsCSSPseudoElements::ePseudo_mozRangeThumb) {
|
|
return mThumbDiv;
|
|
}
|
|
|
|
if (aType == nsCSSPseudoElements::ePseudo_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
|
|
}
|