summaryrefslogtreecommitdiffstats
path: root/layout/generic/StickyScrollContainer.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/generic/StickyScrollContainer.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/generic/StickyScrollContainer.cpp')
-rw-r--r--layout/generic/StickyScrollContainer.cpp391
1 files changed, 391 insertions, 0 deletions
diff --git a/layout/generic/StickyScrollContainer.cpp b/layout/generic/StickyScrollContainer.cpp
new file mode 100644
index 000000000..d61a7e042
--- /dev/null
+++ b/layout/generic/StickyScrollContainer.cpp
@@ -0,0 +1,391 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 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/. */
+
+/**
+ * compute sticky positioning, both during reflow and when the scrolling
+ * container scrolls
+ */
+
+#include "StickyScrollContainer.h"
+#include "nsIFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsLayoutUtils.h"
+#include "RestyleTracker.h"
+
+namespace mozilla {
+
+NS_DECLARE_FRAME_PROPERTY_DELETABLE(StickyScrollContainerProperty,
+ StickyScrollContainer)
+
+StickyScrollContainer::StickyScrollContainer(nsIScrollableFrame* aScrollFrame)
+ : mScrollFrame(aScrollFrame)
+ , mScrollPosition()
+{
+ mScrollFrame->AddScrollPositionListener(this);
+}
+
+StickyScrollContainer::~StickyScrollContainer()
+{
+ mScrollFrame->RemoveScrollPositionListener(this);
+}
+
+// static
+StickyScrollContainer*
+StickyScrollContainer::GetStickyScrollContainerForFrame(nsIFrame* aFrame)
+{
+ nsIScrollableFrame* scrollFrame =
+ nsLayoutUtils::GetNearestScrollableFrame(aFrame->GetParent(),
+ nsLayoutUtils::SCROLLABLE_SAME_DOC |
+ nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+ if (!scrollFrame) {
+ // We might not find any, for instance in the case of
+ // <html style="position: fixed">
+ return nullptr;
+ }
+ FrameProperties props = static_cast<nsIFrame*>(do_QueryFrame(scrollFrame))->
+ Properties();
+ StickyScrollContainer* s = props.Get(StickyScrollContainerProperty());
+ if (!s) {
+ s = new StickyScrollContainer(scrollFrame);
+ props.Set(StickyScrollContainerProperty(), s);
+ }
+ return s;
+}
+
+// static
+void
+StickyScrollContainer::NotifyReparentedFrameAcrossScrollFrameBoundary(nsIFrame* aFrame,
+ nsIFrame* aOldParent)
+{
+ nsIScrollableFrame* oldScrollFrame =
+ nsLayoutUtils::GetNearestScrollableFrame(aOldParent,
+ nsLayoutUtils::SCROLLABLE_SAME_DOC |
+ nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+ if (!oldScrollFrame) {
+ // XXX maybe aFrame has sticky descendants that can be sticky now, but
+ // we aren't going to handle that.
+ return;
+ }
+ FrameProperties props = static_cast<nsIFrame*>(do_QueryFrame(oldScrollFrame))->
+ Properties();
+ StickyScrollContainer* oldSSC = props.Get(StickyScrollContainerProperty());
+ if (!oldSSC) {
+ // aOldParent had no sticky descendants, so aFrame doesn't have any sticky
+ // descendants, and we're done here.
+ return;
+ }
+
+ auto i = oldSSC->mFrames.Length();
+ while (i-- > 0) {
+ nsIFrame* f = oldSSC->mFrames[i];
+ StickyScrollContainer* newSSC = GetStickyScrollContainerForFrame(f);
+ if (newSSC != oldSSC) {
+ oldSSC->RemoveFrame(f);
+ if (newSSC) {
+ newSSC->AddFrame(f);
+ }
+ }
+ }
+}
+
+// static
+StickyScrollContainer*
+StickyScrollContainer::GetStickyScrollContainerForScrollFrame(nsIFrame* aFrame)
+{
+ FrameProperties props = aFrame->Properties();
+ return props.Get(StickyScrollContainerProperty());
+}
+
+static nscoord
+ComputeStickySideOffset(Side aSide, const nsStyleSides& aOffset,
+ nscoord aPercentBasis)
+{
+ if (eStyleUnit_Auto == aOffset.GetUnit(aSide)) {
+ return NS_AUTOOFFSET;
+ } else {
+ return nsLayoutUtils::ComputeCBDependentValue(aPercentBasis,
+ aOffset.Get(aSide));
+ }
+}
+
+// static
+void
+StickyScrollContainer::ComputeStickyOffsets(nsIFrame* aFrame)
+{
+ nsIScrollableFrame* scrollableFrame =
+ nsLayoutUtils::GetNearestScrollableFrame(aFrame->GetParent(),
+ nsLayoutUtils::SCROLLABLE_SAME_DOC |
+ nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN);
+
+ if (!scrollableFrame) {
+ // Bail.
+ return;
+ }
+
+ nsSize scrollContainerSize = scrollableFrame->GetScrolledFrame()->
+ GetContentRectRelativeToSelf().Size();
+
+ nsMargin computedOffsets;
+ const nsStylePosition* position = aFrame->StylePosition();
+
+ computedOffsets.left = ComputeStickySideOffset(eSideLeft, position->mOffset,
+ scrollContainerSize.width);
+ computedOffsets.right = ComputeStickySideOffset(eSideRight, position->mOffset,
+ scrollContainerSize.width);
+ computedOffsets.top = ComputeStickySideOffset(eSideTop, position->mOffset,
+ scrollContainerSize.height);
+ computedOffsets.bottom = ComputeStickySideOffset(eSideBottom, position->mOffset,
+ scrollContainerSize.height);
+
+ // Store the offset
+ FrameProperties props = aFrame->Properties();
+ nsMargin* offsets = props.Get(nsIFrame::ComputedOffsetProperty());
+ if (offsets) {
+ *offsets = computedOffsets;
+ } else {
+ props.Set(nsIFrame::ComputedOffsetProperty(),
+ new nsMargin(computedOffsets));
+ }
+}
+
+void
+StickyScrollContainer::ComputeStickyLimits(nsIFrame* aFrame, nsRect* aStick,
+ nsRect* aContain) const
+{
+ NS_ASSERTION(nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(aFrame),
+ "Can't sticky position individual continuations");
+
+ aStick->SetRect(nscoord_MIN/2, nscoord_MIN/2, nscoord_MAX, nscoord_MAX);
+ aContain->SetRect(nscoord_MIN/2, nscoord_MIN/2, nscoord_MAX, nscoord_MAX);
+
+ const nsMargin* computedOffsets =
+ aFrame->Properties().Get(nsIFrame::ComputedOffsetProperty());
+ if (!computedOffsets) {
+ // We haven't reflowed the scroll frame yet, so offsets haven't been
+ // computed. Bail.
+ return;
+ }
+
+ nsIFrame* scrolledFrame = mScrollFrame->GetScrolledFrame();
+ nsIFrame* cbFrame = aFrame->GetContainingBlock();
+ NS_ASSERTION(cbFrame == scrolledFrame ||
+ nsLayoutUtils::IsProperAncestorFrame(scrolledFrame, cbFrame),
+ "Scroll frame should be an ancestor of the containing block");
+
+ nsRect rect =
+ nsLayoutUtils::GetAllInFlowRectsUnion(aFrame, aFrame->GetParent());
+
+ // Containing block limits for the position of aFrame relative to its parent.
+ // The margin box of the sticky element stays within the content box of the
+ // contaning-block element.
+ if (cbFrame != scrolledFrame) {
+ *aContain = nsLayoutUtils::
+ GetAllInFlowRectsUnion(cbFrame, aFrame->GetParent(),
+ nsLayoutUtils::RECTS_USE_CONTENT_BOX);
+ nsRect marginRect = nsLayoutUtils::
+ GetAllInFlowRectsUnion(aFrame, aFrame->GetParent(),
+ nsLayoutUtils::RECTS_USE_MARGIN_BOX);
+
+ // Deflate aContain by the difference between the union of aFrame's
+ // continuations' margin boxes and the union of their border boxes, so that
+ // by keeping aFrame within aContain, we keep the union of the margin boxes
+ // within the containing block's content box.
+ aContain->Deflate(marginRect - rect);
+
+ // Deflate aContain by the border-box size, to form a constraint on the
+ // upper-left corner of aFrame and continuations.
+ aContain->Deflate(nsMargin(0, rect.width, rect.height, 0));
+ }
+
+ nsMargin sfPadding = scrolledFrame->GetUsedPadding();
+ nsPoint sfOffset = aFrame->GetParent()->GetOffsetTo(scrolledFrame);
+
+ // Top
+ if (computedOffsets->top != NS_AUTOOFFSET) {
+ aStick->SetTopEdge(mScrollPosition.y + sfPadding.top +
+ computedOffsets->top - sfOffset.y);
+ }
+
+ nsSize sfSize = scrolledFrame->GetContentRectRelativeToSelf().Size();
+
+ // Bottom
+ if (computedOffsets->bottom != NS_AUTOOFFSET &&
+ (computedOffsets->top == NS_AUTOOFFSET ||
+ rect.height <= sfSize.height - computedOffsets->TopBottom())) {
+ aStick->SetBottomEdge(mScrollPosition.y + sfPadding.top + sfSize.height -
+ computedOffsets->bottom - rect.height - sfOffset.y);
+ }
+
+ uint8_t direction = cbFrame->StyleVisibility()->mDirection;
+
+ // Left
+ if (computedOffsets->left != NS_AUTOOFFSET &&
+ (computedOffsets->right == NS_AUTOOFFSET ||
+ direction == NS_STYLE_DIRECTION_LTR ||
+ rect.width <= sfSize.width - computedOffsets->LeftRight())) {
+ aStick->SetLeftEdge(mScrollPosition.x + sfPadding.left +
+ computedOffsets->left - sfOffset.x);
+ }
+
+ // Right
+ if (computedOffsets->right != NS_AUTOOFFSET &&
+ (computedOffsets->left == NS_AUTOOFFSET ||
+ direction == NS_STYLE_DIRECTION_RTL ||
+ rect.width <= sfSize.width - computedOffsets->LeftRight())) {
+ aStick->SetRightEdge(mScrollPosition.x + sfPadding.left + sfSize.width -
+ computedOffsets->right - rect.width - sfOffset.x);
+ }
+
+ // These limits are for the bounding box of aFrame's continuations. Convert
+ // to limits for aFrame itself.
+ nsPoint frameOffset = aFrame->GetPosition() - rect.TopLeft();
+ aStick->MoveBy(frameOffset);
+ aContain->MoveBy(frameOffset);
+}
+
+nsPoint
+StickyScrollContainer::ComputePosition(nsIFrame* aFrame) const
+{
+ nsRect stick;
+ nsRect contain;
+ ComputeStickyLimits(aFrame, &stick, &contain);
+
+ nsPoint position = aFrame->GetNormalPosition();
+
+ // For each sticky direction (top, bottom, left, right), move the frame along
+ // the appropriate axis, based on the scroll position, but limit this to keep
+ // the element's margin box within the containing block.
+ position.y = std::max(position.y, std::min(stick.y, contain.YMost()));
+ position.y = std::min(position.y, std::max(stick.YMost(), contain.y));
+ position.x = std::max(position.x, std::min(stick.x, contain.XMost()));
+ position.x = std::min(position.x, std::max(stick.XMost(), contain.x));
+
+ return position;
+}
+
+void
+StickyScrollContainer::GetScrollRanges(nsIFrame* aFrame, nsRect* aOuter,
+ nsRect* aInner) const
+{
+ // We need to use the first in flow; continuation frames should not move
+ // relative to each other and should get identical scroll ranges.
+ // Also, ComputeStickyLimits requires this.
+ nsIFrame *firstCont =
+ nsLayoutUtils::FirstContinuationOrIBSplitSibling(aFrame);
+
+ nsRect stick;
+ nsRect contain;
+ ComputeStickyLimits(firstCont, &stick, &contain);
+
+ aOuter->SetRect(nscoord_MIN/2, nscoord_MIN/2, nscoord_MAX, nscoord_MAX);
+ aInner->SetRect(nscoord_MIN/2, nscoord_MIN/2, nscoord_MAX, nscoord_MAX);
+
+ const nsPoint normalPosition = firstCont->GetNormalPosition();
+
+ // Bottom and top
+ if (stick.YMost() != nscoord_MAX/2) {
+ aOuter->SetTopEdge(contain.y - stick.YMost());
+ aInner->SetTopEdge(normalPosition.y - stick.YMost());
+ }
+
+ if (stick.y != nscoord_MIN/2) {
+ aInner->SetBottomEdge(normalPosition.y - stick.y);
+ aOuter->SetBottomEdge(contain.YMost() - stick.y);
+ }
+
+ // Right and left
+ if (stick.XMost() != nscoord_MAX/2) {
+ aOuter->SetLeftEdge(contain.x - stick.XMost());
+ aInner->SetLeftEdge(normalPosition.x - stick.XMost());
+ }
+
+ if (stick.x != nscoord_MIN/2) {
+ aInner->SetRightEdge(normalPosition.x - stick.x);
+ aOuter->SetRightEdge(contain.XMost() - stick.x);
+ }
+
+ // Make sure |inner| does not extend outside of |outer|. (The consumers of
+ // the Layers API, to which this information is propagated, expect this
+ // invariant to hold.) The calculated value of |inner| can sometimes extend
+ // outside of |outer|, for example due to margin collapsing, since
+ // GetNormalPosition() returns the actual position after margin collapsing,
+ // while |contain| is calculated based on the frame's GetUsedMargin() which
+ // is pre-collapsing.
+ // Note that this doesn't necessarily solve all problems stemming from
+ // comparing pre- and post-collapsing margins (TODO: find a proper solution).
+ *aInner = aInner->Intersect(*aOuter);
+}
+
+void
+StickyScrollContainer::PositionContinuations(nsIFrame* aFrame)
+{
+ NS_ASSERTION(nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(aFrame),
+ "Should be starting from the first continuation");
+ nsPoint translation = ComputePosition(aFrame) - aFrame->GetNormalPosition();
+
+ // Move all continuation frames by the same amount.
+ for (nsIFrame* cont = aFrame; cont;
+ cont = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ cont->SetPosition(cont->GetNormalPosition() + translation);
+ }
+}
+
+void
+StickyScrollContainer::UpdatePositions(nsPoint aScrollPosition,
+ nsIFrame* aSubtreeRoot)
+{
+#ifdef DEBUG
+ {
+ nsIFrame* scrollFrameAsFrame = do_QueryFrame(mScrollFrame);
+ NS_ASSERTION(!aSubtreeRoot || aSubtreeRoot == scrollFrameAsFrame,
+ "If reflowing, should be reflowing the scroll frame");
+ }
+#endif
+ mScrollPosition = aScrollPosition;
+
+ OverflowChangedTracker oct;
+ oct.SetSubtreeRoot(aSubtreeRoot);
+ for (nsTArray<nsIFrame*>::size_type i = 0; i < mFrames.Length(); i++) {
+ nsIFrame* f = mFrames[i];
+ if (!nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(f)) {
+ // This frame was added in nsFrame::Init before we knew it wasn't
+ // the first ib-split-sibling.
+ mFrames.RemoveElementAt(i);
+ --i;
+ continue;
+ }
+
+ if (aSubtreeRoot) {
+ // Reflowing the scroll frame, so recompute offsets.
+ ComputeStickyOffsets(f);
+ }
+ // mFrames will only contain first continuations, because we filter in
+ // nsIFrame::Init.
+ PositionContinuations(f);
+
+ f = f->GetParent();
+ if (f != aSubtreeRoot) {
+ for (nsIFrame* cont = f; cont;
+ cont = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(cont)) {
+ oct.AddFrame(cont, OverflowChangedTracker::CHILDREN_CHANGED);
+ }
+ }
+ }
+ oct.Flush();
+}
+
+void
+StickyScrollContainer::ScrollPositionWillChange(nscoord aX, nscoord aY)
+{
+}
+
+void
+StickyScrollContainer::ScrollPositionDidChange(nscoord aX, nscoord aY)
+{
+ UpdatePositions(nsPoint(aX, aY), nullptr);
+}
+
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-18 10:35:26 +0000