summaryrefslogtreecommitdiffstats
path: root/layout/generic/ScrollSnap.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--layout/generic/ScrollSnap.cpp633
1 files changed, 633 insertions, 0 deletions
diff --git a/layout/generic/ScrollSnap.cpp b/layout/generic/ScrollSnap.cpp
new file mode 100644
index 0000000000..a031b9b673
--- /dev/null
+++ b/layout/generic/ScrollSnap.cpp
@@ -0,0 +1,633 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ScrollSnap.h"
+
+#include "FrameMetrics.h"
+
+#include "mozilla/ServoStyleConsts.h"
+#include "nsIFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsPresContext.h"
+#include "nsTArray.h"
+#include "mozilla/StaticPrefs_layout.h"
+
+namespace mozilla {
+
+using layers::ScrollSnapInfo;
+
+/**
+ * Keeps track of the current best edge to snap to. The criteria for
+ * adding an edge depends on the scrolling unit.
+ */
+class CalcSnapPoints final {
+ public:
+ CalcSnapPoints(ScrollUnit aUnit, ScrollSnapFlags aSnapFlags,
+ const nsPoint& aDestination, const nsPoint& aStartPos);
+ struct SnapPosition {
+ SnapPosition() = default;
+
+ SnapPosition(nscoord aPosition, StyleScrollSnapStop aScrollSnapStop,
+ ScrollSnapTargetId aTargetId)
+ : mPosition(aPosition),
+ mScrollSnapStop(aScrollSnapStop),
+ mTargetId(aTargetId) {}
+
+ nscoord mPosition;
+ StyleScrollSnapStop mScrollSnapStop;
+ ScrollSnapTargetId mTargetId;
+ };
+
+ void AddHorizontalEdge(const SnapPosition& aEdge);
+ void AddVerticalEdge(const SnapPosition& aEdge);
+
+ struct CandidateTracker {
+ explicit CandidateTracker(nscoord aDestination)
+ : mBestEdge(SnapPosition{aDestination, StyleScrollSnapStop::Normal,
+ ScrollSnapTargetId::None}) {
+ // We use NSCoordSaturatingSubtract to calculate the distance between a
+ // given position and this second best edge position so that it can be an
+ // uninitialized value as the maximum possible value, because the first
+ // distance calculation would always be nscoord_MAX.
+ mSecondBestEdge = SnapPosition{nscoord_MAX, StyleScrollSnapStop::Normal,
+ ScrollSnapTargetId::None};
+ mEdgeFound = false;
+ }
+
+ // keeps track of the position of the current best edge on this axis.
+ SnapPosition mBestEdge;
+ // keeps track of the position of the current second best edge on the
+ // opposite side of the best edge on this axis.
+ SnapPosition mSecondBestEdge;
+ bool mEdgeFound; // true if mBestEdge is storing a valid edge.
+
+ // Assuming in most cases there's no multiple coincide snap points.
+ AutoTArray<ScrollSnapTargetId, 1> mTargetIds;
+ };
+ void AddEdge(const SnapPosition& aEdge, nscoord aDestination,
+ nscoord aStartPos, nscoord aScrollingDirection,
+ CandidateTracker* aCandidateTracker);
+ SnapTarget GetBestEdge() const;
+ nscoord XDistanceBetweenBestAndSecondEdge() const {
+ return std::abs(NSCoordSaturatingSubtract(
+ mTrackerOnX.mSecondBestEdge.mPosition, mTrackerOnX.mBestEdge.mPosition,
+ nscoord_MAX));
+ }
+ nscoord YDistanceBetweenBestAndSecondEdge() const {
+ return std::abs(NSCoordSaturatingSubtract(
+ mTrackerOnY.mSecondBestEdge.mPosition, mTrackerOnY.mBestEdge.mPosition,
+ nscoord_MAX));
+ }
+ const nsPoint& Destination() const { return mDestination; }
+
+ protected:
+ ScrollUnit mUnit;
+ ScrollSnapFlags mSnapFlags;
+ nsPoint mDestination; // gives the position after scrolling but before
+ // snapping
+ nsPoint mStartPos; // gives the position before scrolling
+ nsIntPoint mScrollingDirection; // always -1, 0, or 1
+ CandidateTracker mTrackerOnX;
+ CandidateTracker mTrackerOnY;
+};
+
+CalcSnapPoints::CalcSnapPoints(ScrollUnit aUnit, ScrollSnapFlags aSnapFlags,
+ const nsPoint& aDestination,
+ const nsPoint& aStartPos)
+ : mUnit(aUnit),
+ mSnapFlags(aSnapFlags),
+ mDestination(aDestination),
+ mStartPos(aStartPos),
+ mTrackerOnX(aDestination.x),
+ mTrackerOnY(aDestination.y) {
+ MOZ_ASSERT(aSnapFlags != ScrollSnapFlags::Disabled);
+
+ nsPoint direction = aDestination - aStartPos;
+ mScrollingDirection = nsIntPoint(0, 0);
+ if (direction.x < 0) {
+ mScrollingDirection.x = -1;
+ }
+ if (direction.x > 0) {
+ mScrollingDirection.x = 1;
+ }
+ if (direction.y < 0) {
+ mScrollingDirection.y = -1;
+ }
+ if (direction.y > 0) {
+ mScrollingDirection.y = 1;
+ }
+}
+
+SnapTarget CalcSnapPoints::GetBestEdge() const {
+ return SnapTarget{
+ nsPoint(
+ mTrackerOnX.mEdgeFound ? mTrackerOnX.mBestEdge.mPosition
+ // In the case of IntendedEndPosition (i.e. the destination point is
+ // explicitely specied, e.g. scrollTo) use the destination point if we
+ // didn't find any candidates.
+ : !(mSnapFlags & ScrollSnapFlags::IntendedDirection) ? mDestination.x
+ : mStartPos.x,
+ mTrackerOnY.mEdgeFound ? mTrackerOnY.mBestEdge.mPosition
+ // Same as above X axis case, use the destination point if we didn't
+ // find any candidates.
+ : !(mSnapFlags & ScrollSnapFlags::IntendedDirection) ? mDestination.y
+ : mStartPos.y),
+ ScrollSnapTargetIds{mTrackerOnX.mTargetIds, mTrackerOnY.mTargetIds}};
+}
+
+void CalcSnapPoints::AddHorizontalEdge(const SnapPosition& aEdge) {
+ AddEdge(aEdge, mDestination.y, mStartPos.y, mScrollingDirection.y,
+ &mTrackerOnY);
+}
+
+void CalcSnapPoints::AddVerticalEdge(const SnapPosition& aEdge) {
+ AddEdge(aEdge, mDestination.x, mStartPos.x, mScrollingDirection.x,
+ &mTrackerOnX);
+}
+
+void CalcSnapPoints::AddEdge(const SnapPosition& aEdge, nscoord aDestination,
+ nscoord aStartPos, nscoord aScrollingDirection,
+ CandidateTracker* aCandidateTracker) {
+ if (mSnapFlags & ScrollSnapFlags::IntendedDirection) {
+ // In the case of intended direction, we only want to snap to points ahead
+ // of the direction we are scrolling.
+ if (aScrollingDirection == 0 ||
+ (aEdge.mPosition - aStartPos) * aScrollingDirection <= 0) {
+ // The scroll direction is neutral - will not hit a snap point, or the
+ // edge is not in the direction we are scrolling, skip it.
+ return;
+ }
+ }
+
+ if (!aCandidateTracker->mEdgeFound) {
+ aCandidateTracker->mBestEdge = aEdge;
+ aCandidateTracker->mTargetIds =
+ AutoTArray<ScrollSnapTargetId, 1>{aEdge.mTargetId};
+ aCandidateTracker->mEdgeFound = true;
+ return;
+ }
+
+ auto isPreferredStopAlways = [&](const SnapPosition& aSnapPosition) -> bool {
+ MOZ_ASSERT(mSnapFlags & ScrollSnapFlags::IntendedDirection);
+ // In the case of intended direction scroll operations, `scroll-snap-stop:
+ // always` snap points in between the start point and the scroll destination
+ // are preferable preferable. In other words any `scroll-snap-stop: always`
+ // snap points can be handled as if it's `scroll-snap-stop: normal`.
+ return aSnapPosition.mScrollSnapStop == StyleScrollSnapStop::Always &&
+ std::abs(aSnapPosition.mPosition - aStartPos) <
+ std::abs(aDestination - aStartPos);
+ };
+
+ const bool isOnOppositeSide =
+ ((aEdge.mPosition - aDestination) > 0) !=
+ ((aCandidateTracker->mBestEdge.mPosition - aDestination) > 0);
+ const nscoord distanceFromStart = aEdge.mPosition - aStartPos;
+ // A utility function to update the best and the second best edges in the
+ // given conditions.
+ // |aIsCloserThanBest| True if the current candidate is closer than the best
+ // edge.
+ // |aIsCloserThanSecond| True if the current candidate is closer than
+ // the second best edge.
+ const nscoord distanceFromDestination = aEdge.mPosition - aDestination;
+ auto updateBestEdges = [&](bool aIsCloserThanBest, bool aIsCloserThanSecond) {
+ if (aIsCloserThanBest) {
+ if (mSnapFlags & ScrollSnapFlags::IntendedDirection &&
+ isPreferredStopAlways(aEdge)) {
+ // In the case of intended direction scroll operations and the new best
+ // candidate is `scroll-snap-stop: always` and if it's closer to the
+ // start position than the destination, thus we won't use the second
+ // best edge since even if the snap port of the best edge covers entire
+ // snapport, the `scroll-snap-stop: always` snap point is preferred than
+ // any points.
+ // NOTE: We've already ignored snap points behind start points so that
+ // we can use std::abs here in the comparison.
+ //
+ // For example, if there's a `scroll-snap-stop: always` in between the
+ // start point and destination, no `snap-overflow` mechanism should
+ // happen, if there's `scroll-snap-stop: always` further than the
+ // destination, `snap-overflow` might happen something like below
+ // diagram.
+ // start always dest other always
+ // |------------|---------|------|
+ aCandidateTracker->mSecondBestEdge = aEdge;
+ } else if (isOnOppositeSide) {
+ // Replace the second best edge with the current best edge only if the
+ // new best edge (aEdge) is on the opposite side of the current best
+ // edge.
+ aCandidateTracker->mSecondBestEdge = aCandidateTracker->mBestEdge;
+ }
+ aCandidateTracker->mBestEdge = aEdge;
+ aCandidateTracker->mTargetIds =
+ AutoTArray<ScrollSnapTargetId, 1>{aEdge.mTargetId};
+ } else {
+ if (aEdge.mPosition == aCandidateTracker->mBestEdge.mPosition) {
+ aCandidateTracker->mTargetIds.AppendElement(aEdge.mTargetId);
+ }
+ if (aIsCloserThanSecond && isOnOppositeSide) {
+ aCandidateTracker->mSecondBestEdge = aEdge;
+ }
+ }
+ };
+
+ bool isCandidateOfBest = false;
+ bool isCandidateOfSecondBest = false;
+ switch (mUnit) {
+ case ScrollUnit::DEVICE_PIXELS:
+ case ScrollUnit::LINES:
+ case ScrollUnit::WHOLE: {
+ isCandidateOfBest =
+ std::abs(distanceFromDestination) <
+ std::abs(aCandidateTracker->mBestEdge.mPosition - aDestination);
+ isCandidateOfSecondBest =
+ std::abs(distanceFromDestination) <
+ std::abs(NSCoordSaturatingSubtract(
+ aCandidateTracker->mSecondBestEdge.mPosition, aDestination,
+ nscoord_MAX));
+ break;
+ }
+ case ScrollUnit::PAGES: {
+ // distance to the edge from the scrolling destination in the direction of
+ // scrolling
+ nscoord overshoot = distanceFromDestination * aScrollingDirection;
+ // distance to the current best edge from the scrolling destination in the
+ // direction of scrolling
+ nscoord curOvershoot =
+ (aCandidateTracker->mBestEdge.mPosition - aDestination) *
+ aScrollingDirection;
+
+ nscoord secondOvershoot =
+ NSCoordSaturatingSubtract(
+ aCandidateTracker->mSecondBestEdge.mPosition, aDestination,
+ nscoord_MAX) *
+ aScrollingDirection;
+
+ // edges between the current position and the scrolling destination are
+ // favoured to preserve context
+ if (overshoot < 0) {
+ isCandidateOfBest = overshoot > curOvershoot || curOvershoot >= 0;
+ isCandidateOfSecondBest =
+ overshoot > secondOvershoot || secondOvershoot >= 0;
+ }
+ // if there are no edges between the current position and the scrolling
+ // destination the closest edge beyond the destination is used
+ if (overshoot > 0) {
+ isCandidateOfBest = overshoot < curOvershoot;
+ isCandidateOfSecondBest = overshoot < secondOvershoot;
+ }
+ }
+ }
+
+ if (mSnapFlags & ScrollSnapFlags::IntendedDirection) {
+ if (isPreferredStopAlways(aEdge)) {
+ // If the given position is `scroll-snap-stop: always` and if the position
+ // is in between the start and the destination positions, update the best
+ // position based on the distance from the __start__ point.
+ isCandidateOfBest =
+ std::abs(distanceFromStart) <
+ std::abs(aCandidateTracker->mBestEdge.mPosition - aStartPos);
+ } else if (isPreferredStopAlways(aCandidateTracker->mBestEdge)) {
+ // If we've found a preferable `scroll-snap-stop:always` position as the
+ // best, do not update it unless the given position is also
+ // `scroll-snap-stop: always`.
+ isCandidateOfBest = false;
+ }
+ }
+
+ updateBestEdges(isCandidateOfBest, isCandidateOfSecondBest);
+}
+
+static void ProcessSnapPositions(CalcSnapPoints& aCalcSnapPoints,
+ const ScrollSnapInfo& aSnapInfo) {
+ for (const auto& target : aSnapInfo.mSnapTargets) {
+ if (!target.IsValidFor(aCalcSnapPoints.Destination(),
+ aSnapInfo.mSnapportSize)) {
+ continue;
+ }
+
+ if (target.mSnapPositionX &&
+ aSnapInfo.mScrollSnapStrictnessX != StyleScrollSnapStrictness::None) {
+ aCalcSnapPoints.AddVerticalEdge(
+ {*target.mSnapPositionX, target.mScrollSnapStop, target.mTargetId});
+ }
+ if (target.mSnapPositionY &&
+ aSnapInfo.mScrollSnapStrictnessY != StyleScrollSnapStrictness::None) {
+ aCalcSnapPoints.AddHorizontalEdge(
+ {*target.mSnapPositionY, target.mScrollSnapStop, target.mTargetId});
+ }
+ }
+}
+
+Maybe<SnapTarget> ScrollSnapUtils::GetSnapPointForDestination(
+ const ScrollSnapInfo& aSnapInfo, ScrollUnit aUnit,
+ ScrollSnapFlags aSnapFlags, const nsRect& aScrollRange,
+ const nsPoint& aStartPos, const nsPoint& aDestination) {
+ if (aSnapInfo.mScrollSnapStrictnessY == StyleScrollSnapStrictness::None &&
+ aSnapInfo.mScrollSnapStrictnessX == StyleScrollSnapStrictness::None) {
+ return Nothing();
+ }
+
+ if (!aSnapInfo.HasSnapPositions()) {
+ return Nothing();
+ }
+
+ CalcSnapPoints calcSnapPoints(aUnit, aSnapFlags, aDestination, aStartPos);
+
+ ProcessSnapPositions(calcSnapPoints, aSnapInfo);
+
+ // If the distance between the first and the second candidate snap points
+ // is larger than the snapport size and the snapport is covered by larger
+ // elements, any points inside the covering area should be valid snap
+ // points.
+ // https://drafts.csswg.org/css-scroll-snap-1/#snap-overflow
+ // NOTE: |aDestination| sometimes points outside of the scroll range, e.g.
+ // by the APZC fling, so for the overflow checks we need to clamp it.
+ nsPoint clampedDestination = aScrollRange.ClampPoint(aDestination);
+ for (auto range : aSnapInfo.mXRangeWiderThanSnapport) {
+ if (range.IsValid(clampedDestination.x, aSnapInfo.mSnapportSize.width) &&
+ calcSnapPoints.XDistanceBetweenBestAndSecondEdge() >
+ aSnapInfo.mSnapportSize.width) {
+ calcSnapPoints.AddVerticalEdge(CalcSnapPoints::SnapPosition{
+ clampedDestination.x, StyleScrollSnapStop::Normal, range.mTargetId});
+ break;
+ }
+ }
+ for (auto range : aSnapInfo.mYRangeWiderThanSnapport) {
+ if (range.IsValid(clampedDestination.y, aSnapInfo.mSnapportSize.height) &&
+ calcSnapPoints.YDistanceBetweenBestAndSecondEdge() >
+ aSnapInfo.mSnapportSize.height) {
+ calcSnapPoints.AddHorizontalEdge(CalcSnapPoints::SnapPosition{
+ clampedDestination.y, StyleScrollSnapStop::Normal, range.mTargetId});
+ break;
+ }
+ }
+
+ bool snapped = false;
+ auto finalPos = calcSnapPoints.GetBestEdge();
+ nscoord proximityThreshold =
+ StaticPrefs::layout_css_scroll_snap_proximity_threshold();
+ proximityThreshold = nsPresContext::CSSPixelsToAppUnits(proximityThreshold);
+ if (aSnapInfo.mScrollSnapStrictnessY ==
+ StyleScrollSnapStrictness::Proximity &&
+ std::abs(aDestination.y - finalPos.mPosition.y) > proximityThreshold) {
+ finalPos.mPosition.y = aDestination.y;
+ } else if (aSnapInfo.mScrollSnapStrictnessY !=
+ StyleScrollSnapStrictness::None &&
+ aDestination.y != finalPos.mPosition.y) {
+ snapped = true;
+ }
+ if (aSnapInfo.mScrollSnapStrictnessX ==
+ StyleScrollSnapStrictness::Proximity &&
+ std::abs(aDestination.x - finalPos.mPosition.x) > proximityThreshold) {
+ finalPos.mPosition.x = aDestination.x;
+ } else if (aSnapInfo.mScrollSnapStrictnessX !=
+ StyleScrollSnapStrictness::None &&
+ aDestination.x != finalPos.mPosition.x) {
+ snapped = true;
+ }
+ return snapped ? Some(finalPos) : Nothing();
+}
+
+ScrollSnapTargetId ScrollSnapUtils::GetTargetIdFor(const nsIFrame* aFrame) {
+ MOZ_ASSERT(aFrame && aFrame->GetContent());
+ return ScrollSnapTargetId{reinterpret_cast<uintptr_t>(aFrame->GetContent())};
+}
+
+static std::pair<Maybe<nscoord>, Maybe<nscoord>> GetCandidateInLastTargets(
+ const layers::ScrollSnapInfo& aSnapInfo, const nsPoint& aCurrentPosition,
+ const UniquePtr<ScrollSnapTargetIds>& aLastSnapTargetIds,
+ const nsIContent* aFocusedContent) {
+ ScrollSnapTargetId targetIdForFocusedContent = ScrollSnapTargetId::None;
+ if (aFocusedContent && aFocusedContent->GetPrimaryFrame()) {
+ targetIdForFocusedContent =
+ ScrollSnapUtils::GetTargetIdFor(aFocusedContent->GetPrimaryFrame());
+ }
+
+ // Note: Below algorithm doesn't care about cases where the last snap point
+ // was on an element larger than the snapport since it's not clear to us
+ // what we should do for now.
+ // https://github.com/w3c/csswg-drafts/issues/7438
+ const ScrollSnapInfo::SnapTarget* focusedTarget = nullptr;
+ Maybe<nscoord> x, y;
+ for (const auto& target : aSnapInfo.mSnapTargets) {
+ if (!target.IsValidFor(aCurrentPosition, aSnapInfo.mSnapportSize)) {
+ continue;
+ }
+
+ if (target.mSnapPositionX &&
+ aSnapInfo.mScrollSnapStrictnessX != StyleScrollSnapStrictness::None) {
+ if (aLastSnapTargetIds->mIdsOnX.Contains(target.mTargetId)) {
+ if (targetIdForFocusedContent == target.mTargetId) {
+ // If we've already found the candidate on Y axis, but if snapping to
+ // the point results this target is scrolled out, we can't use it.
+ if ((y && !target.mSnapArea.Intersects(
+ nsRect(nsPoint(*target.mSnapPositionX, *y),
+ aSnapInfo.mSnapportSize)))) {
+ y.reset();
+ }
+
+ focusedTarget = &target;
+ // If the focused one is valid, then it's the candidate.
+ x = target.mSnapPositionX;
+ }
+
+ if (!x) {
+ // Update the candidate on X axis only if
+ // 1) we haven't yet found the candidate on Y axis
+ // 2) or if we've found the candiate on Y axis and if snapping to the
+ // candidate position result the target element is visible inside
+ // the snapport.
+ if (!y || (y && target.mSnapArea.Intersects(
+ nsRect(nsPoint(*target.mSnapPositionX, *y),
+ aSnapInfo.mSnapportSize)))) {
+ x = target.mSnapPositionX;
+ }
+ }
+ }
+ }
+ if (target.mSnapPositionY &&
+ aSnapInfo.mScrollSnapStrictnessY != StyleScrollSnapStrictness::None) {
+ if (aLastSnapTargetIds->mIdsOnY.Contains(target.mTargetId)) {
+ if (targetIdForFocusedContent == target.mTargetId) {
+ NS_ASSERTION(!focusedTarget || focusedTarget == &target,
+ "If the focused target has been found on X axis, the "
+ "target should be same");
+ // If we've already found the candidate on X axis other than the
+ // focused one, but if snapping to the point results this target is
+ // scrolled out, we can't use it.
+ if (!focusedTarget && (x && !target.mSnapArea.Intersects(nsRect(
+ nsPoint(*x, *target.mSnapPositionY),
+ aSnapInfo.mSnapportSize)))) {
+ x.reset();
+ }
+
+ focusedTarget = &target;
+ y = target.mSnapPositionY;
+ }
+
+ if (!y) {
+ if (!x || (x && target.mSnapArea.Intersects(
+ nsRect(nsPoint(*x, *target.mSnapPositionY),
+ aSnapInfo.mSnapportSize)))) {
+ y = target.mSnapPositionY;
+ }
+ }
+ }
+ }
+
+ // If we found candidates on both axes, it's the one we need.
+ if (x && y &&
+ // If we haven't found the focused target, it's possible that we haven't
+ // iterated it, don't break in such case.
+ (targetIdForFocusedContent == ScrollSnapTargetId::None ||
+ focusedTarget)) {
+ break;
+ }
+ }
+
+ return {x, y};
+}
+
+Maybe<mozilla::SnapTarget> ScrollSnapUtils::GetSnapPointForResnap(
+ const layers::ScrollSnapInfo& aSnapInfo, const nsRect& aScrollRange,
+ const nsPoint& aCurrentPosition,
+ const UniquePtr<ScrollSnapTargetIds>& aLastSnapTargetIds,
+ const nsIContent* aFocusedContent) {
+ if (!aLastSnapTargetIds) {
+ return GetSnapPointForDestination(aSnapInfo, ScrollUnit::DEVICE_PIXELS,
+ ScrollSnapFlags::IntendedEndPosition,
+ aScrollRange, aCurrentPosition,
+ aCurrentPosition);
+ }
+
+ auto [x, y] = GetCandidateInLastTargets(aSnapInfo, aCurrentPosition,
+ aLastSnapTargetIds, aFocusedContent);
+ if (!x && !y) {
+ // In the worst case there's no longer valid snap points previously snapped,
+ // try to find new valid snap points.
+ return GetSnapPointForDestination(aSnapInfo, ScrollUnit::DEVICE_PIXELS,
+ ScrollSnapFlags::IntendedEndPosition,
+ aScrollRange, aCurrentPosition,
+ aCurrentPosition);
+ }
+
+ // If there's no candidate on one of the axes in the last snap points, try
+ // to find a new candidate.
+ if (!x || !y) {
+ nsPoint newPosition =
+ nsPoint(x ? *x : aCurrentPosition.x, y ? *y : aCurrentPosition.y);
+ CalcSnapPoints calcSnapPoints(ScrollUnit::DEVICE_PIXELS,
+ ScrollSnapFlags::IntendedEndPosition,
+ newPosition, newPosition);
+ for (const auto& target : aSnapInfo.mSnapTargets) {
+ if (!target.IsValidFor(newPosition, aSnapInfo.mSnapportSize)) {
+ continue;
+ }
+
+ if (!x && target.mSnapPositionX &&
+ aSnapInfo.mScrollSnapStrictnessX != StyleScrollSnapStrictness::None) {
+ calcSnapPoints.AddVerticalEdge(
+ {*target.mSnapPositionX, target.mScrollSnapStop, target.mTargetId});
+ }
+ if (!y && target.mSnapPositionY &&
+ aSnapInfo.mScrollSnapStrictnessY != StyleScrollSnapStrictness::None) {
+ calcSnapPoints.AddHorizontalEdge(
+ {*target.mSnapPositionY, target.mScrollSnapStop, target.mTargetId});
+ }
+ }
+ auto finalPos = calcSnapPoints.GetBestEdge();
+ if (!x) {
+ x = Some(finalPos.mPosition.x);
+ }
+ if (!y) {
+ y = Some(finalPos.mPosition.y);
+ }
+ }
+
+ SnapTarget snapTarget{nsPoint(*x, *y)};
+ // Collect snap points where the position is still same as the new snap
+ // position.
+ for (const auto& target : aSnapInfo.mSnapTargets) {
+ if (!target.IsValidFor(snapTarget.mPosition, aSnapInfo.mSnapportSize)) {
+ continue;
+ }
+
+ if (target.mSnapPositionX &&
+ aSnapInfo.mScrollSnapStrictnessX != StyleScrollSnapStrictness::None &&
+ target.mSnapPositionX == x) {
+ snapTarget.mTargetIds.mIdsOnX.AppendElement(target.mTargetId);
+ }
+
+ if (target.mSnapPositionY &&
+ aSnapInfo.mScrollSnapStrictnessY != StyleScrollSnapStrictness::None &&
+ target.mSnapPositionY == y) {
+ snapTarget.mTargetIds.mIdsOnY.AppendElement(target.mTargetId);
+ }
+ }
+ return Some(snapTarget);
+}
+
+void ScrollSnapUtils::PostPendingResnapIfNeededFor(nsIFrame* aFrame) {
+ ScrollSnapTargetId id = GetTargetIdFor(aFrame);
+ if (id == ScrollSnapTargetId::None) {
+ return;
+ }
+
+ if (nsIScrollableFrame* sf = nsLayoutUtils::GetNearestScrollableFrame(
+ aFrame, nsLayoutUtils::SCROLLABLE_SAME_DOC |
+ nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN)) {
+ sf->PostPendingResnapIfNeeded(aFrame);
+ }
+}
+
+void ScrollSnapUtils::PostPendingResnapFor(nsIFrame* aFrame) {
+ if (nsIScrollableFrame* sf = nsLayoutUtils::GetNearestScrollableFrame(
+ aFrame, nsLayoutUtils::SCROLLABLE_SAME_DOC |
+ nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN)) {
+ sf->PostPendingResnap();
+ }
+}
+
+bool ScrollSnapUtils::NeedsToRespectTargetWritingMode(
+ const nsSize& aSnapAreaSize, const nsSize& aSnapportSize) {
+ // Use the writing-mode on the target element if the snap area is larger than
+ // the snapport.
+ // https://drafts.csswg.org/css-scroll-snap/#snap-scope
+ //
+ // It's unclear `larger` means that the size is larger than only on the target
+ // axis. If it doesn't, it will pick the same axis in the case where only one
+ // axis is larger. For example, if an element size is (200 x 10) and the
+ // snapport size is (100 x 100) and if the element's writing mode is different
+ // from the scroller's writing mode, then `scroll-snap-align: start start`
+ // will be conflict.
+ return aSnapAreaSize.width > aSnapportSize.width ||
+ aSnapAreaSize.height > aSnapportSize.height;
+}
+
+static nsRect InflateByScrollMargin(const nsRect& aTargetRect,
+ const nsMargin& aScrollMargin,
+ const nsRect& aScrolledRect) {
+ // Inflate the rect by scroll-margin.
+ nsRect result = aTargetRect;
+ result.Inflate(aScrollMargin);
+
+ // But don't be beyond the limit boundary.
+ return result.Intersect(aScrolledRect);
+}
+
+nsRect ScrollSnapUtils::GetSnapAreaFor(const nsIFrame* aFrame,
+ const nsIFrame* aScrolledFrame,
+ const nsRect& aScrolledRect) {
+ nsRect targetRect = nsLayoutUtils::TransformFrameRectToAncestor(
+ aFrame, aFrame->GetRectRelativeToSelf(), aScrolledFrame);
+
+ // The snap area contains scroll-margin values.
+ // https://drafts.csswg.org/css-scroll-snap-1/#scroll-snap-area
+ nsMargin scrollMargin = aFrame->StyleMargin()->GetScrollMargin();
+ return InflateByScrollMargin(targetRect, scrollMargin, aScrolledRect);
+}
+
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 02:17:41 +0000