layout/forms/nsRangeFrame.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsRangeFrame.h"
   8
   9 #include "ListMutationObserver.h"
  10 #include "mozilla/Assertions.h"
  11 #include "mozilla/PresShell.h"
  12 #include "mozilla/TouchEvents.h"
  13
  14 #include "gfxContext.h"
  15 #include "nsContentCreatorFunctions.h"
  16 #include "nsCSSRendering.h"
  17 #include "nsDisplayList.h"
  18 #include "nsIContent.h"
  19 #include "nsLayoutUtils.h"
  20 #include "mozilla/dom/Document.h"
  21 #include "nsGkAtoms.h"
  22 #include "mozilla/dom/HTMLDataListElement.h"
  23 #include "mozilla/dom/HTMLInputElement.h"
  24 #include "mozilla/dom/HTMLOptionElement.h"
  25 #include "mozilla/dom/MutationEventBinding.h"
  26 #include "nsPresContext.h"
  27 #include "nsNodeInfoManager.h"
  28 #include "mozilla/dom/Element.h"
  29 #include "mozilla/ServoStyleSet.h"
  30 #include "nsTArray.h"
  31
  32 #ifdef ACCESSIBILITY
  33 #  include "nsAccessibilityService.h"
  34 #endif
  35
  36 // Our intrinsic size is 12em in the main-axis and 1.3em in the cross-axis.
  37 #define MAIN_AXIS_EM_SIZE 12
  38 #define CROSS_AXIS_EM_SIZE 1.3f
  39
  40 using namespace mozilla;
  41 using namespace mozilla::dom;
  42 using namespace mozilla::image;
  43
  44 nsIFrame* NS_NewRangeFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
  45   return new (aPresShell) nsRangeFrame(aStyle, aPresShell->GetPresContext());
  46 }
  47
  48 nsRangeFrame::nsRangeFrame(ComputedStyle* aStyle, nsPresContext* aPresContext)
  49     : nsContainerFrame(aStyle, aPresContext, kClassID) {}
  50
  51 void nsRangeFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
  52                         nsIFrame* aPrevInFlow) {
  53   nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
  54   if (InputElement().HasAttr(nsGkAtoms::list_)) {
  55     mListMutationObserver = new ListMutationObserver(*this);
  56   }
  57 }
  58
  59 nsRangeFrame::~nsRangeFrame() = default;
  60
  61 NS_IMPL_FRAMEARENA_HELPERS(nsRangeFrame)
  62
  63 NS_QUERYFRAME_HEAD(nsRangeFrame)
  64   NS_QUERYFRAME_ENTRY(nsRangeFrame)
  65   NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
  66 NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
  67
  68 void nsRangeFrame::Destroy(DestroyContext& aContext) {
  69   NS_ASSERTION(!GetPrevContinuation() && !GetNextContinuation(),
  70                "nsRangeFrame should not have continuations; if it does we "
  71                "need to call RegUnregAccessKey only for the first.");
  72
  73   if (mListMutationObserver) {
  74     mListMutationObserver->Detach();
  75   }
  76   aContext.AddAnonymousContent(mTrackDiv.forget());
  77   aContext.AddAnonymousContent(mProgressDiv.forget());
  78   aContext.AddAnonymousContent(mThumbDiv.forget());
  79   nsContainerFrame::Destroy(aContext);
  80 }
  81
  82 static already_AddRefed<Element> MakeAnonymousDiv(
  83     Document& aDoc, PseudoStyleType aOldPseudoType,
  84     PseudoStyleType aModernPseudoType,
  85     nsTArray<nsIAnonymousContentCreator::ContentInfo>& aElements) {
  86   RefPtr<Element> result = aDoc.CreateHTMLElement(nsGkAtoms::div);
  87
  88   // Associate the pseudo-element with the anonymous child.
  89   if (StaticPrefs::layout_css_modern_range_pseudos_enabled()) {
  90     result->SetPseudoElementType(aModernPseudoType);
  91   } else {
  92     result->SetPseudoElementType(aOldPseudoType);
  93   }
  94
  95   // XXX(Bug 1631371) Check if this should use a fallible operation as it
  96   // pretended earlier, or change the return type to void.
  97   aElements.AppendElement(result);
  98
  99   return result.forget();
 100 }
 101
 102 nsresult nsRangeFrame::CreateAnonymousContent(
 103     nsTArray<ContentInfo>& aElements) {
 104   Document* doc = mContent->OwnerDoc();
 105   // Create the ::-moz-range-track pseudo-element (a div):
 106   mTrackDiv = MakeAnonymousDiv(*doc, PseudoStyleType::mozRangeTrack,
 107                                PseudoStyleType::sliderTrack, aElements);
 108   // Create the ::-moz-range-progress pseudo-element (a div):
 109   mProgressDiv = MakeAnonymousDiv(*doc, PseudoStyleType::mozRangeProgress,
 110                                   PseudoStyleType::sliderFill, aElements);
 111   // Create the ::-moz-range-thumb pseudo-element (a div):
 112   mThumbDiv = MakeAnonymousDiv(*doc, PseudoStyleType::mozRangeThumb,
 113                                PseudoStyleType::sliderThumb, aElements);
 114   return NS_OK;
 115 }
 116
 117 void nsRangeFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
 118                                             uint32_t aFilter) {
 119   if (mTrackDiv) {
 120     aElements.AppendElement(mTrackDiv);
 121   }
 122
 123   if (mProgressDiv) {
 124     aElements.AppendElement(mProgressDiv);
 125   }
 126
 127   if (mThumbDiv) {
 128     aElements.AppendElement(mThumbDiv);
 129   }
 130 }
 131
 132 void nsRangeFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
 133                                     const nsDisplayListSet& aLists) {
 134   const nsStyleDisplay* disp = StyleDisplay();
 135   if (IsThemed(disp)) {
 136     DisplayBorderBackgroundOutline(aBuilder, aLists);
 137     // Only create items for the thumb. Specifically, we do not want the track
 138     // to paint, since *our* background is used to paint the track, and we don't
 139     // want the unthemed track painting over the top of the themed track.
 140     // This logic is copied from
 141     // nsContainerFrame::BuildDisplayListForNonBlockChildren as
 142     // called by BuildDisplayListForInline.
 143     if (nsIFrame* thumb = mThumbDiv->GetPrimaryFrame()) {
 144       nsDisplayListSet set(aLists, aLists.Content());
 145       BuildDisplayListForChild(aBuilder, thumb, set, DisplayChildFlag::Inline);
 146     }
 147   } else {
 148     BuildDisplayListForInline(aBuilder, aLists);
 149   }
 150 }
 151
 152 void nsRangeFrame::Reflow(nsPresContext* aPresContext,
 153                           ReflowOutput& aDesiredSize,
 154                           const ReflowInput& aReflowInput,
 155                           nsReflowStatus& aStatus) {
 156   MarkInReflow();
 157   DO_GLOBAL_REFLOW_COUNT("nsRangeFrame");
 158   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
 159   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
 160
 161   NS_ASSERTION(mTrackDiv, "::-moz-range-track div must exist!");
 162   NS_ASSERTION(mProgressDiv, "::-moz-range-progress div must exist!");
 163   NS_ASSERTION(mThumbDiv, "::-moz-range-thumb div must exist!");
 164   NS_ASSERTION(!GetPrevContinuation() && !GetNextContinuation(),
 165                "nsRangeFrame should not have continuations; if it does we "
 166                "need to call RegUnregAccessKey only for the first.");
 167
 168   WritingMode wm = aReflowInput.GetWritingMode();
 169   nscoord computedBSize = aReflowInput.ComputedBSize();
 170   if (computedBSize == NS_UNCONSTRAINEDSIZE) {
 171     computedBSize = 0;
 172   }
 173   const auto borderPadding = aReflowInput.ComputedLogicalBorderPadding(wm);
 174   LogicalSize finalSize(
 175       wm, aReflowInput.ComputedISize() + borderPadding.IStartEnd(wm),
 176       computedBSize + borderPadding.BStartEnd(wm));
 177   aDesiredSize.SetSize(wm, finalSize);
 178
 179   ReflowAnonymousContent(aPresContext, aDesiredSize, aReflowInput);
 180
 181   aDesiredSize.SetOverflowAreasToDesiredBounds();
 182
 183   nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame();
 184   if (trackFrame) {
 185     ConsiderChildOverflow(aDesiredSize.mOverflowAreas, trackFrame);
 186   }
 187
 188   nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
 189   if (rangeProgressFrame) {
 190     ConsiderChildOverflow(aDesiredSize.mOverflowAreas, rangeProgressFrame);
 191   }
 192
 193   nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
 194   if (thumbFrame) {
 195     ConsiderChildOverflow(aDesiredSize.mOverflowAreas, thumbFrame);
 196   }
 197
 198   FinishAndStoreOverflow(&aDesiredSize);
 199
 200   MOZ_ASSERT(aStatus.IsEmpty(), "This type of frame can't be split.");
 201 }
 202
 203 void nsRangeFrame::ReflowAnonymousContent(nsPresContext* aPresContext,
 204                                           ReflowOutput& aDesiredSize,
 205                                           const ReflowInput& aReflowInput) {
 206   // The width/height of our content box, which is the available width/height
 207   // for our anonymous content:
 208   nscoord rangeFrameContentBoxWidth = aReflowInput.ComputedWidth();
 209   nscoord rangeFrameContentBoxHeight = aReflowInput.ComputedHeight();
 210   if (rangeFrameContentBoxHeight == NS_UNCONSTRAINEDSIZE) {
 211     rangeFrameContentBoxHeight = 0;
 212   }
 213
 214   nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame();
 215
 216   if (trackFrame) {  // display:none?
 217
 218     // Position the track:
 219     // The idea here is that we allow content authors to style the width,
 220     // height, border and padding of the track, but we ignore margin and
 221     // positioning properties and do the positioning ourself to keep the center
 222     // of the track's border box on the center of the nsRangeFrame's content
 223     // box.
 224
 225     WritingMode wm = trackFrame->GetWritingMode();
 226     LogicalSize availSize = aReflowInput.ComputedSize(wm);
 227     availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
 228     ReflowInput trackReflowInput(aPresContext, aReflowInput, trackFrame,
 229                                  availSize);
 230
 231     // Find the x/y position of the track frame such that it will be positioned
 232     // as described above. These coordinates are with respect to the
 233     // nsRangeFrame's border-box.
 234     nscoord trackX = rangeFrameContentBoxWidth / 2;
 235     nscoord trackY = rangeFrameContentBoxHeight / 2;
 236
 237     // Account for the track's border and padding (we ignore its margin):
 238     trackX -= trackReflowInput.ComputedPhysicalBorderPadding().left +
 239               trackReflowInput.ComputedWidth() / 2;
 240     trackY -= trackReflowInput.ComputedPhysicalBorderPadding().top +
 241               trackReflowInput.ComputedHeight() / 2;
 242
 243     // Make relative to our border box instead of our content box:
 244     trackX += aReflowInput.ComputedPhysicalBorderPadding().left;
 245     trackY += aReflowInput.ComputedPhysicalBorderPadding().top;
 246
 247     nsReflowStatus frameStatus;
 248     ReflowOutput trackDesiredSize(aReflowInput);
 249     ReflowChild(trackFrame, aPresContext, trackDesiredSize, trackReflowInput,
 250                 trackX, trackY, ReflowChildFlags::Default, frameStatus);
 251     MOZ_ASSERT(
 252         frameStatus.IsFullyComplete(),
 253         "We gave our child unconstrained height, so it should be complete");
 254     FinishReflowChild(trackFrame, aPresContext, trackDesiredSize,
 255                       &trackReflowInput, trackX, trackY,
 256                       ReflowChildFlags::Default);
 257   }
 258
 259   nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
 260
 261   if (thumbFrame) {  // display:none?
 262     WritingMode wm = thumbFrame->GetWritingMode();
 263     LogicalSize availSize = aReflowInput.ComputedSize(wm);
 264     availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
 265     ReflowInput thumbReflowInput(aPresContext, aReflowInput, thumbFrame,
 266                                  availSize);
 267
 268     // Where we position the thumb depends on its size, so we first reflow
 269     // the thumb at {0,0} to obtain its size, then position it afterwards.
 270
 271     nsReflowStatus frameStatus;
 272     ReflowOutput thumbDesiredSize(aReflowInput);
 273     ReflowChild(thumbFrame, aPresContext, thumbDesiredSize, thumbReflowInput, 0,
 274                 0, ReflowChildFlags::Default, frameStatus);
 275     MOZ_ASSERT(
 276         frameStatus.IsFullyComplete(),
 277         "We gave our child unconstrained height, so it should be complete");
 278     FinishReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
 279                       &thumbReflowInput, 0, 0, ReflowChildFlags::Default);
 280     DoUpdateThumbPosition(thumbFrame,
 281                           nsSize(aDesiredSize.Width(), aDesiredSize.Height()));
 282   }
 283
 284   nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
 285
 286   if (rangeProgressFrame) {  // display:none?
 287     WritingMode wm = rangeProgressFrame->GetWritingMode();
 288     LogicalSize availSize = aReflowInput.ComputedSize(wm);
 289     availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
 290     ReflowInput progressReflowInput(aPresContext, aReflowInput,
 291                                     rangeProgressFrame, availSize);
 292
 293     // We first reflow the range-progress frame at {0,0} to obtain its
 294     // unadjusted dimensions, then we adjust it to so that the appropriate edge
 295     // ends at the thumb.
 296
 297     nsReflowStatus frameStatus;
 298     ReflowOutput progressDesiredSize(aReflowInput);
 299     ReflowChild(rangeProgressFrame, aPresContext, progressDesiredSize,
 300                 progressReflowInput, 0, 0, ReflowChildFlags::Default,
 301                 frameStatus);
 302     MOZ_ASSERT(
 303         frameStatus.IsFullyComplete(),
 304         "We gave our child unconstrained height, so it should be complete");
 305     FinishReflowChild(rangeProgressFrame, aPresContext, progressDesiredSize,
 306                       &progressReflowInput, 0, 0, ReflowChildFlags::Default);
 307     DoUpdateRangeProgressFrame(
 308         rangeProgressFrame,
 309         nsSize(aDesiredSize.Width(), aDesiredSize.Height()));
 310   }
 311 }
 312
 313 #ifdef ACCESSIBILITY
 314 a11y::AccType nsRangeFrame::AccessibleType() { return a11y::eHTMLRangeType; }
 315 #endif
 316
 317 double nsRangeFrame::GetValueAsFractionOfRange() {
 318   const auto& input = InputElement();
 319   if (MOZ_UNLIKELY(!input.IsDoneCreating())) {
 320     // Our element isn't done being created, so its values haven't yet been
 321     // sanitized! (It's rare that we'd be reflowed when our element is in this
 322     // state, but it can happen if the parser decides to yield while processing
 323     // its tasks to build the element.)  We can't trust that any of our numeric
 324     // values will make sense until they've been sanitized; so for now, just
 325     // use 0.0 as a fallback fraction-of-range value here (i.e. behave as if
 326     // we're at our minimum, which is how the spec handles some edge cases).
 327     return 0.0;
 328   }
 329   return GetDoubleAsFractionOfRange(input.GetValueAsDecimal());
 330 }
 331
 332 double nsRangeFrame::GetDoubleAsFractionOfRange(const Decimal& aValue) {
 333   auto& input = InputElement();
 334
 335   Decimal minimum = input.GetMinimum();
 336   Decimal maximum = input.GetMaximum();
 337
 338   MOZ_ASSERT(aValue.isFinite() && minimum.isFinite() && maximum.isFinite(),
 339              "type=range should have a default maximum/minimum");
 340
 341   if (maximum <= minimum) {
 342     // Avoid rounding triggering the assert by checking against an epsilon.
 343     MOZ_ASSERT((aValue - minimum).abs().toDouble() <
 344                    std::numeric_limits<float>::epsilon(),
 345                "Unsanitized value");
 346     return 0.0;
 347   }
 348
 349   MOZ_ASSERT(aValue >= minimum && aValue <= maximum, "Unsanitized value");
 350
 351   return ((aValue - minimum) / (maximum - minimum)).toDouble();
 352 }
 353
 354 Decimal nsRangeFrame::GetValueAtEventPoint(WidgetGUIEvent* aEvent) {
 355   MOZ_ASSERT(
 356       aEvent->mClass == eMouseEventClass || aEvent->mClass == eTouchEventClass,
 357       "Unexpected event type - aEvent->mRefPoint may be meaningless");
 358
 359   MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast");
 360   dom::HTMLInputElement* input =
 361       static_cast<dom::HTMLInputElement*>(GetContent());
 362
 363   MOZ_ASSERT(input->ControlType() == FormControlType::InputRange);
 364
 365   Decimal minimum = input->GetMinimum();
 366   Decimal maximum = input->GetMaximum();
 367   MOZ_ASSERT(minimum.isFinite() && maximum.isFinite(),
 368              "type=range should have a default maximum/minimum");
 369   if (maximum <= minimum) {
 370     return minimum;
 371   }
 372   Decimal range = maximum - minimum;
 373
 374   LayoutDeviceIntPoint absPoint;
 375   if (aEvent->mClass == eTouchEventClass) {
 376     MOZ_ASSERT(aEvent->AsTouchEvent()->mTouches.Length() == 1,
 377                "Unexpected number of mTouches");
 378     absPoint = aEvent->AsTouchEvent()->mTouches[0]->mRefPoint;
 379   } else {
 380     absPoint = aEvent->mRefPoint;
 381   }
 382   nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
 383       aEvent, absPoint, RelativeTo{this});
 384
 385   if (point == nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)) {
 386     // We don't want to change the current value for this error state.
 387     return static_cast<dom::HTMLInputElement*>(GetContent())
 388         ->GetValueAsDecimal();
 389   }
 390
 391   nsRect rangeContentRect = GetContentRectRelativeToSelf();
 392   nsSize thumbSize;
 393
 394   if (IsThemed()) {
 395     // We need to get the size of the thumb from the theme.
 396     nsPresContext* pc = PresContext();
 397     LayoutDeviceIntSize size = pc->Theme()->GetMinimumWidgetSize(
 398         pc, this, StyleAppearance::RangeThumb);
 399     thumbSize =
 400         LayoutDeviceIntSize::ToAppUnits(size, pc->AppUnitsPerDevPixel());
 401     // For GTK, GetMinimumWidgetSize returns zero for the thumb dimension
 402     // perpendicular to the orientation of the slider.  That's okay since we
 403     // only care about the dimension in the direction of the slider when using
 404     // |thumbSize| below, but it means this assertion need to check
 405     // IsHorizontal().
 406     MOZ_ASSERT((IsHorizontal() && thumbSize.width > 0) ||
 407                    (!IsHorizontal() && thumbSize.height > 0),
 408                "The thumb is expected to take up some slider space");
 409   } else {
 410     nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
 411     if (thumbFrame) {  // diplay:none?
 412       thumbSize = thumbFrame->GetSize();
 413     }
 414   }
 415
 416   Decimal fraction;
 417   if (IsHorizontal()) {
 418     nscoord traversableDistance = rangeContentRect.width - thumbSize.width;
 419     if (traversableDistance <= 0) {
 420       return minimum;
 421     }
 422     nscoord posAtStart = rangeContentRect.x + thumbSize.width / 2;
 423     nscoord posAtEnd = posAtStart + traversableDistance;
 424     nscoord posOfPoint = mozilla::clamped(point.x, posAtStart, posAtEnd);
 425     fraction = Decimal(posOfPoint - posAtStart) / Decimal(traversableDistance);
 426     if (IsRightToLeft()) {
 427       fraction = Decimal(1) - fraction;
 428     }
 429   } else {
 430     nscoord traversableDistance = rangeContentRect.height - thumbSize.height;
 431     if (traversableDistance <= 0) {
 432       return minimum;
 433     }
 434     nscoord posAtStart = rangeContentRect.y + thumbSize.height / 2;
 435     nscoord posAtEnd = posAtStart + traversableDistance;
 436     nscoord posOfPoint = mozilla::clamped(point.y, posAtStart, posAtEnd);
 437     // For a vertical range, the top (posAtStart) is the highest value, so we
 438     // subtract the fraction from 1.0 to get that polarity correct.
 439     fraction = Decimal(posOfPoint - posAtStart) / Decimal(traversableDistance);
 440     if (IsUpwards()) {
 441       fraction = Decimal(1) - fraction;
 442     }
 443   }
 444
 445   MOZ_ASSERT(fraction >= Decimal(0) && fraction <= Decimal(1));
 446   return minimum + fraction * range;
 447 }
 448
 449 void nsRangeFrame::UpdateForValueChange() {
 450   if (IsSubtreeDirty()) {
 451     return;  // we're going to be updated when we reflow
 452   }
 453   nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
 454   nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
 455   if (!rangeProgressFrame && !thumbFrame) {
 456     return;  // diplay:none?
 457   }
 458   if (rangeProgressFrame) {
 459     DoUpdateRangeProgressFrame(rangeProgressFrame, GetSize());
 460   }
 461   if (thumbFrame) {
 462     DoUpdateThumbPosition(thumbFrame, GetSize());
 463   }
 464   if (IsThemed()) {
 465     // We don't know the exact dimensions or location of the thumb when native
 466     // theming is applied, so we just repaint the entire range.
 467     InvalidateFrame();
 468   }
 469
 470 #ifdef ACCESSIBILITY
 471   if (nsAccessibilityService* accService = GetAccService()) {
 472     accService->RangeValueChanged(PresShell(), mContent);
 473   }
 474 #endif
 475
 476   SchedulePaint();
 477 }
 478
 479 nsTArray<Decimal> nsRangeFrame::TickMarks() {
 480   nsTArray<Decimal> tickMarks;
 481   auto& input = InputElement();
 482   auto* list = input.GetList();
 483   if (!list) {
 484     return tickMarks;
 485   }
 486   auto min = input.GetMinimum();
 487   auto max = input.GetMaximum();
 488   auto* options = list->Options();
 489   nsAutoString label;
 490   for (uint32_t i = 0; i < options->Length(); ++i) {
 491     auto* item = options->Item(i);
 492     auto* option = HTMLOptionElement::FromNode(item);
 493     MOZ_ASSERT(option);
 494     if (option->Disabled()) {
 495       continue;
 496     }
 497     nsAutoString str;
 498     option->GetValue(str);
 499     auto tickMark = HTMLInputElement::StringToDecimal(str);
 500     if (tickMark.isNaN() || tickMark < min || tickMark > max ||
 501         input.ValueIsStepMismatch(tickMark)) {
 502       continue;
 503     }
 504     tickMarks.AppendElement(tickMark);
 505   }
 506   tickMarks.Sort();
 507   return tickMarks;
 508 }
 509
 510 Decimal nsRangeFrame::NearestTickMark(const Decimal& aValue) {
 511   auto tickMarks = TickMarks();
 512   if (tickMarks.IsEmpty() || aValue.isNaN()) {
 513     return Decimal::nan();
 514   }
 515   size_t index;
 516   if (BinarySearch(tickMarks, 0, tickMarks.Length(), aValue, &index)) {
 517     return tickMarks[index];
 518   }
 519   if (index == tickMarks.Length()) {
 520     return tickMarks.LastElement();
 521   }
 522   if (index == 0) {
 523     return tickMarks[0];
 524   }
 525   const auto& smallerTickMark = tickMarks[index - 1];
 526   const auto& largerTickMark = tickMarks[index];
 527   MOZ_ASSERT(smallerTickMark < aValue);
 528   MOZ_ASSERT(largerTickMark > aValue);
 529   return (aValue - smallerTickMark).abs() < (aValue - largerTickMark).abs()
 530              ? smallerTickMark
 531              : largerTickMark;
 532 }
 533
 534 mozilla::dom::HTMLInputElement& nsRangeFrame::InputElement() const {
 535   MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast");
 536   auto& input = *static_cast<dom::HTMLInputElement*>(GetContent());
 537   MOZ_ASSERT(input.ControlType() == FormControlType::InputRange);
 538   return input;
 539 }
 540
 541 void nsRangeFrame::DoUpdateThumbPosition(nsIFrame* aThumbFrame,
 542                                          const nsSize& aRangeSize) {
 543   MOZ_ASSERT(aThumbFrame);
 544
 545   // The idea here is that we want to position the thumb so that the center
 546   // of the thumb is on an imaginary line drawn from the middle of one edge
 547   // of the range frame's content box to the middle of the opposite edge of
 548   // its content box (the opposite edges being the left/right edge if the
 549   // range is horizontal, or else the top/bottom edges if the range is
 550   // vertical). How far along this line the center of the thumb is placed
 551   // depends on the value of the range.
 552
 553   nsMargin borderAndPadding = GetUsedBorderAndPadding();
 554   nsPoint newPosition(borderAndPadding.left, borderAndPadding.top);
 555
 556   nsSize rangeContentBoxSize(aRangeSize);
 557   rangeContentBoxSize.width -= borderAndPadding.LeftRight();
 558   rangeContentBoxSize.height -= borderAndPadding.TopBottom();
 559
 560   nsSize thumbSize = aThumbFrame->GetSize();
 561   double fraction = GetValueAsFractionOfRange();
 562   MOZ_ASSERT(fraction >= 0.0 && fraction <= 1.0);
 563
 564   if (IsHorizontal()) {
 565     if (thumbSize.width < rangeContentBoxSize.width) {
 566       nscoord traversableDistance = rangeContentBoxSize.width - thumbSize.width;
 567       if (IsRightToLeft()) {
 568         newPosition.x += NSToCoordRound((1.0 - fraction) * traversableDistance);
 569       } else {
 570         newPosition.x += NSToCoordRound(fraction * traversableDistance);
 571       }
 572       newPosition.y += (rangeContentBoxSize.height - thumbSize.height) / 2;
 573     }
 574   } else {
 575     if (thumbSize.height < rangeContentBoxSize.height) {
 576       nscoord traversableDistance =
 577           rangeContentBoxSize.height - thumbSize.height;
 578       newPosition.x += (rangeContentBoxSize.width - thumbSize.width) / 2;
 579       if (IsUpwards()) {
 580         newPosition.y += NSToCoordRound((1.0 - fraction) * traversableDistance);
 581       } else {
 582         newPosition.y += NSToCoordRound(fraction * traversableDistance);
 583       }
 584     }
 585   }
 586   aThumbFrame->SetPosition(newPosition);
 587 }
 588
 589 void nsRangeFrame::DoUpdateRangeProgressFrame(nsIFrame* aRangeProgressFrame,
 590                                               const nsSize& aRangeSize) {
 591   MOZ_ASSERT(aRangeProgressFrame);
 592
 593   // The idea here is that we want to position the ::-moz-range-progress
 594   // pseudo-element so that the center line running along its length is on the
 595   // corresponding center line of the nsRangeFrame's content box. In the other
 596   // dimension, we align the "start" edge of the ::-moz-range-progress
 597   // pseudo-element's border-box with the corresponding edge of the
 598   // nsRangeFrame's content box, and we size the progress element's border-box
 599   // to have a length of GetValueAsFractionOfRange() times the nsRangeFrame's
 600   // content-box size.
 601
 602   nsMargin borderAndPadding = GetUsedBorderAndPadding();
 603   nsSize progSize = aRangeProgressFrame->GetSize();
 604   nsRect progRect(borderAndPadding.left, borderAndPadding.top, progSize.width,
 605                   progSize.height);
 606
 607   nsSize rangeContentBoxSize(aRangeSize);
 608   rangeContentBoxSize.width -= borderAndPadding.LeftRight();
 609   rangeContentBoxSize.height -= borderAndPadding.TopBottom();
 610
 611   double fraction = GetValueAsFractionOfRange();
 612   MOZ_ASSERT(fraction >= 0.0 && fraction <= 1.0);
 613
 614   if (IsHorizontal()) {
 615     nscoord progLength = NSToCoordRound(fraction * rangeContentBoxSize.width);
 616     if (IsRightToLeft()) {
 617       progRect.x += rangeContentBoxSize.width - progLength;
 618     }
 619     progRect.y += (rangeContentBoxSize.height - progSize.height) / 2;
 620     progRect.width = progLength;
 621   } else {
 622     nscoord progLength = NSToCoordRound(fraction * rangeContentBoxSize.height);
 623     progRect.x += (rangeContentBoxSize.width - progSize.width) / 2;
 624     if (IsUpwards()) {
 625       progRect.y += rangeContentBoxSize.height - progLength;
 626     }
 627     progRect.height = progLength;
 628   }
 629   aRangeProgressFrame->SetRect(progRect);
 630 }
 631
 632 nsresult nsRangeFrame::AttributeChanged(int32_t aNameSpaceID,
 633                                         nsAtom* aAttribute, int32_t aModType) {
 634   NS_ASSERTION(mTrackDiv, "The track div must exist!");
 635   NS_ASSERTION(mThumbDiv, "The thumb div must exist!");
 636
 637   if (aNameSpaceID == kNameSpaceID_None) {
 638     if (aAttribute == nsGkAtoms::value || aAttribute == nsGkAtoms::min ||
 639         aAttribute == nsGkAtoms::max || aAttribute == nsGkAtoms::step) {
 640       // We want to update the position of the thumb, except in one special
 641       // case: If the value attribute is being set, it is possible that we are
 642       // in the middle of a type change away from type=range, under the
 643       // SetAttr(..., nsGkAtoms::value, ...) call in HTMLInputElement::
 644       // HandleTypeChange. In that case the HTMLInputElement's type will
 645       // already have changed, and if we call UpdateForValueChange()
 646       // we'll fail the asserts under that call that check the type of our
 647       // HTMLInputElement. Given that we're changing away from being a range
 648       // and this frame will shortly be destroyed, there's no point in calling
 649       // UpdateForValueChange() anyway.
 650       MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast");
 651       bool typeIsRange =
 652           static_cast<dom::HTMLInputElement*>(GetContent())->ControlType() ==
 653           FormControlType::InputRange;
 654       // If script changed the <input>'s type before setting these attributes
 655       // then we don't need to do anything since we are going to be reframed.
 656       if (typeIsRange) {
 657         UpdateForValueChange();
 658       }
 659     } else if (aAttribute == nsGkAtoms::orient) {
 660       PresShell()->FrameNeedsReflow(this, IntrinsicDirty::None,
 661                                     NS_FRAME_IS_DIRTY);
 662     } else if (aAttribute == nsGkAtoms::list_) {
 663       const bool isRemoval = aModType == MutationEvent_Binding::REMOVAL;
 664       if (mListMutationObserver) {
 665         mListMutationObserver->Detach();
 666         if (isRemoval) {
 667           mListMutationObserver = nullptr;
 668         } else {
 669           mListMutationObserver->Attach();
 670         }
 671       } else if (!isRemoval) {
 672         mListMutationObserver = new ListMutationObserver(*this, true);
 673       }
 674     }
 675   }
 676
 677   return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
 678 }
 679
 680 nscoord nsRangeFrame::AutoCrossSize(Length aEm) {
 681   nscoord minCrossSize(0);
 682   if (IsThemed()) {
 683     nsPresContext* pc = PresContext();
 684     LayoutDeviceIntSize size = pc->Theme()->GetMinimumWidgetSize(
 685         pc, this, StyleAppearance::RangeThumb);
 686     minCrossSize =
 687         pc->DevPixelsToAppUnits(IsHorizontal() ? size.height : size.width);
 688   }
 689   return std::max(minCrossSize, aEm.ScaledBy(CROSS_AXIS_EM_SIZE).ToAppUnits());
 690 }
 691
 692 static mozilla::Length OneEm(nsRangeFrame* aFrame) {
 693   return aFrame->StyleFont()->mFont.size.ScaledBy(
 694       nsLayoutUtils::FontSizeInflationFor(aFrame));
 695 }
 696
 697 LogicalSize nsRangeFrame::ComputeAutoSize(
 698     gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
 699     nscoord aAvailableISize, const LogicalSize& aMargin,
 700     const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides,
 701     ComputeSizeFlags aFlags) {
 702   bool isInlineOriented = IsInlineOriented();
 703   auto em = OneEm(this);
 704
 705   const WritingMode wm = GetWritingMode();
 706   LogicalSize autoSize(wm);
 707   if (isInlineOriented) {
 708     autoSize.ISize(wm) = em.ScaledBy(MAIN_AXIS_EM_SIZE).ToAppUnits();
 709     autoSize.BSize(wm) = AutoCrossSize(em);
 710   } else {
 711     autoSize.ISize(wm) = AutoCrossSize(em);
 712     autoSize.BSize(wm) = em.ScaledBy(MAIN_AXIS_EM_SIZE).ToAppUnits();
 713   }
 714
 715   return autoSize.ConvertTo(aWM, wm);
 716 }
 717
 718 nscoord nsRangeFrame::GetMinISize(gfxContext* aRenderingContext) {
 719   const auto* pos = StylePosition();
 720   auto wm = GetWritingMode();
 721   if (pos->ISize(wm).HasPercent()) {
 722     // https://drafts.csswg.org/css-sizing-3/#percentage-sizing
 723     // https://drafts.csswg.org/css-sizing-3/#min-content-zero
 724     return nsLayoutUtils::ResolveToLength<true>(
 725         pos->ISize(wm).AsLengthPercentage(), nscoord(0));
 726   }
 727   return GetPrefISize(aRenderingContext);
 728 }
 729
 730 nscoord nsRangeFrame::GetPrefISize(gfxContext* aRenderingContext) {
 731   auto em = OneEm(this);
 732   if (IsInlineOriented()) {
 733     return em.ScaledBy(MAIN_AXIS_EM_SIZE).ToAppUnits();
 734   }
 735   return AutoCrossSize(em);
 736 }
 737
 738 bool nsRangeFrame::IsHorizontal() const {
 739   dom::HTMLInputElement* element =
 740       static_cast<dom::HTMLInputElement*>(GetContent());
 741   return element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
 742                               nsGkAtoms::horizontal, eCaseMatters) ||
 743          (!element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
 744                                 nsGkAtoms::vertical, eCaseMatters) &&
 745           GetWritingMode().IsVertical() ==
 746               element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
 747                                    nsGkAtoms::block, eCaseMatters));
 748 }
 749
 750 double nsRangeFrame::GetMin() const {
 751   return static_cast<dom::HTMLInputElement*>(GetContent())
 752       ->GetMinimum()
 753       .toDouble();
 754 }
 755
 756 double nsRangeFrame::GetMax() const {
 757   return static_cast<dom::HTMLInputElement*>(GetContent())
 758       ->GetMaximum()
 759       .toDouble();
 760 }
 761
 762 double nsRangeFrame::GetValue() const {
 763   return static_cast<dom::HTMLInputElement*>(GetContent())
 764       ->GetValueAsDecimal()
 765       .toDouble();
 766 }
 767
 768 bool nsRangeFrame::ShouldUseNativeStyle() const {
 769   nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame();
 770   nsIFrame* progressFrame = mProgressDiv->GetPrimaryFrame();
 771   nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
 772
 773   return StyleDisplay()->EffectiveAppearance() == StyleAppearance::Range &&
 774          trackFrame &&
 775          !trackFrame->Style()->HasAuthorSpecifiedBorderOrBackground() &&
 776          progressFrame &&
 777          !progressFrame->Style()->HasAuthorSpecifiedBorderOrBackground() &&
 778          thumbFrame &&
 779          !thumbFrame->Style()->HasAuthorSpecifiedBorderOrBackground();
 780 }