зеркало из https://github.com/mozilla/gecko-dev.git
7965 строки
308 KiB
C++
7965 строки
308 KiB
C++
/* -*- 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/. */
|
|
|
|
/* rendering object to wrap rendering objects that should be scrollable */
|
|
|
|
#include "nsGfxScrollFrame.h"
|
|
|
|
#include "nsIXULRuntime.h"
|
|
#include "ActiveLayerTracker.h"
|
|
#include "base/compiler_specific.h"
|
|
#include "DisplayItemClip.h"
|
|
#include "Layers.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIContentViewer.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsView.h"
|
|
#include "nsViewportInfo.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "mozilla/dom/DocumentInlines.h"
|
|
#include "mozilla/gfx/gfxVars.h"
|
|
#include "nsFontMetrics.h"
|
|
#include "nsBoxLayoutState.h"
|
|
#include "mozilla/dom/NodeInfo.h"
|
|
#include "nsScrollbarFrame.h"
|
|
#include "nsINode.h"
|
|
#include "nsIScrollbarMediator.h"
|
|
#include "nsITextControlFrame.h"
|
|
#include "nsILayoutHistoryState.h"
|
|
#include "nsNodeInfoManager.h"
|
|
#include "nsContentCreatorFunctions.h"
|
|
#include "nsStyleTransformMatrix.h"
|
|
#include "mozilla/PresState.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsHTMLDocument.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsBidiPresUtils.h"
|
|
#include "nsBidiUtils.h"
|
|
#include "nsDocShell.h"
|
|
#include "mozilla/ContentEvents.h"
|
|
#include "mozilla/DisplayPortUtils.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/ScopeExit.h"
|
|
#include "mozilla/ScrollbarPreferences.h"
|
|
#include "mozilla/SVGOuterSVGFrame.h"
|
|
#include "mozilla/ViewportUtils.h"
|
|
#include "mozilla/LookAndFeel.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/Event.h"
|
|
#include "mozilla/dom/HTMLMarqueeElement.h"
|
|
#include <stdint.h>
|
|
#include "mozilla/MathAlgorithms.h"
|
|
#include "mozilla/Telemetry.h"
|
|
#include "FrameLayerBuilder.h"
|
|
#include "nsSubDocumentFrame.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "ScrollbarActivity.h"
|
|
#include "nsRefreshDriver.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsIScrollPositionListener.h"
|
|
#include "StickyScrollContainer.h"
|
|
#include "nsIFrameInlines.h"
|
|
#include "gfxPlatform.h"
|
|
#include "mozilla/StaticPrefs_apz.h"
|
|
#include "mozilla/StaticPrefs_general.h"
|
|
#include "mozilla/StaticPrefs_layers.h"
|
|
#include "mozilla/StaticPrefs_layout.h"
|
|
#include "mozilla/StaticPrefs_mousewheel.h"
|
|
#include "mozilla/ToString.h"
|
|
#include "ScrollAnimationPhysics.h"
|
|
#include "ScrollAnimationBezierPhysics.h"
|
|
#include "ScrollAnimationMSDPhysics.h"
|
|
#include "ScrollSnap.h"
|
|
#include "UnitTransforms.h"
|
|
#include "nsSliderFrame.h"
|
|
#include "ViewportFrame.h"
|
|
#include "mozilla/gfx/gfxVars.h"
|
|
#include "mozilla/layers/APZCCallbackHelper.h"
|
|
#include "mozilla/layers/APZPublicUtils.h"
|
|
#include "mozilla/layers/AxisPhysicsModel.h"
|
|
#include "mozilla/layers/AxisPhysicsMSDModel.h"
|
|
#include "mozilla/layers/LayerTransactionChild.h"
|
|
#include "mozilla/layers/ScrollLinkedEffectDetector.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "MobileViewportManager.h"
|
|
#include "VisualViewport.h"
|
|
#include <algorithm>
|
|
#include <cstdlib> // for std::abs(int/long)
|
|
#include <cmath> // for std::abs(float/double)
|
|
#include <tuple> // for std::tie
|
|
|
|
static mozilla::LazyLogModule sApzPaintSkipLog("apz.paintskip");
|
|
#define PAINT_SKIP_LOG(...) \
|
|
MOZ_LOG(sApzPaintSkipLog, LogLevel::Debug, (__VA_ARGS__))
|
|
static mozilla::LazyLogModule sScrollRestoreLog("scrollrestore");
|
|
#define SCROLLRESTORE_LOG(...) \
|
|
MOZ_LOG(sScrollRestoreLog, LogLevel::Debug, (__VA_ARGS__))
|
|
static mozilla::LazyLogModule sRootScrollbarsLog("rootscrollbars");
|
|
#define ROOT_SCROLLBAR_LOG(...) \
|
|
if (mHelper.mIsRoot) { \
|
|
MOZ_LOG(sRootScrollbarsLog, LogLevel::Debug, (__VA_ARGS__)); \
|
|
}
|
|
static mozilla::LazyLogModule sDisplayportLog("apz.displayport");
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::gfx;
|
|
using namespace mozilla::layers;
|
|
using namespace mozilla::layout;
|
|
using nsStyleTransformMatrix::TransformReferenceBox;
|
|
|
|
static ScrollDirections GetOverflowChange(const nsRect& aCurScrolledRect,
|
|
const nsRect& aPrevScrolledRect) {
|
|
ScrollDirections result;
|
|
if (aPrevScrolledRect.x != aCurScrolledRect.x ||
|
|
aPrevScrolledRect.width != aCurScrolledRect.width) {
|
|
result += ScrollDirection::eHorizontal;
|
|
}
|
|
if (aPrevScrolledRect.y != aCurScrolledRect.y ||
|
|
aPrevScrolledRect.height != aCurScrolledRect.height) {
|
|
result += ScrollDirection::eVertical;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* This class handles the dispatching of scroll events to content.
|
|
*
|
|
* Scroll events are posted to the refresh driver via
|
|
* nsRefreshDriver::PostScrollEvent(), and they are fired during a refresh
|
|
* driver tick, after running requestAnimationFrame callbacks but before
|
|
* the style flush. This allows rAF callbacks to perform scrolling and have
|
|
* that scrolling be reflected on the same refresh driver tick, while at
|
|
* the same time allowing scroll event listeners to make style changes and
|
|
* have those style changes be reflected on the same refresh driver tick.
|
|
*
|
|
* ScrollEvents cannot be refresh observers, because none of the existing
|
|
* categories of refresh observers (FlushType::Style, FlushType::Layout,
|
|
* and FlushType::Display) are run at the desired time in a refresh driver
|
|
* tick. They behave similarly to refresh observers in that their presence
|
|
* causes the refresh driver to tick.
|
|
*
|
|
* ScrollEvents are one-shot runnables; the refresh driver drops them after
|
|
* running them.
|
|
*/
|
|
class ScrollFrameHelper::ScrollEvent : public Runnable {
|
|
public:
|
|
NS_DECL_NSIRUNNABLE
|
|
explicit ScrollEvent(ScrollFrameHelper* aHelper, bool aDelayed);
|
|
void Revoke() { mHelper = nullptr; }
|
|
|
|
private:
|
|
ScrollFrameHelper* mHelper;
|
|
};
|
|
|
|
class ScrollFrameHelper::ScrollEndEvent : public Runnable {
|
|
public:
|
|
NS_DECL_NSIRUNNABLE
|
|
explicit ScrollEndEvent(ScrollFrameHelper* aHelper);
|
|
void Revoke() { mHelper = nullptr; }
|
|
|
|
private:
|
|
ScrollFrameHelper* mHelper;
|
|
};
|
|
|
|
class ScrollFrameHelper::AsyncScrollPortEvent : public Runnable {
|
|
public:
|
|
NS_DECL_NSIRUNNABLE
|
|
explicit AsyncScrollPortEvent(ScrollFrameHelper* helper)
|
|
: Runnable("ScrollFrameHelper::AsyncScrollPortEvent"), mHelper(helper) {}
|
|
void Revoke() { mHelper = nullptr; }
|
|
|
|
private:
|
|
ScrollFrameHelper* mHelper;
|
|
};
|
|
|
|
class ScrollFrameHelper::ScrolledAreaEvent : public Runnable {
|
|
public:
|
|
NS_DECL_NSIRUNNABLE
|
|
explicit ScrolledAreaEvent(ScrollFrameHelper* helper)
|
|
: Runnable("ScrollFrameHelper::ScrolledAreaEvent"), mHelper(helper) {}
|
|
void Revoke() { mHelper = nullptr; }
|
|
|
|
private:
|
|
ScrollFrameHelper* mHelper;
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
//----------nsHTMLScrollFrame-------------------------------------------
|
|
|
|
nsHTMLScrollFrame* NS_NewHTMLScrollFrame(PresShell* aPresShell,
|
|
ComputedStyle* aStyle, bool aIsRoot) {
|
|
return new (aPresShell)
|
|
nsHTMLScrollFrame(aStyle, aPresShell->GetPresContext(), aIsRoot);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsHTMLScrollFrame)
|
|
|
|
nsHTMLScrollFrame::nsHTMLScrollFrame(ComputedStyle* aStyle,
|
|
nsPresContext* aPresContext,
|
|
nsIFrame::ClassID aID, bool aIsRoot)
|
|
: nsContainerFrame(aStyle, aPresContext, aID),
|
|
mHelper(ALLOW_THIS_IN_INITIALIZER_LIST(this), aIsRoot) {}
|
|
|
|
void nsHTMLScrollFrame::ScrollbarActivityStarted() const {
|
|
if (mHelper.mScrollbarActivity) {
|
|
mHelper.mScrollbarActivity->ActivityStarted();
|
|
}
|
|
}
|
|
|
|
void nsHTMLScrollFrame::ScrollbarActivityStopped() const {
|
|
if (mHelper.mScrollbarActivity) {
|
|
mHelper.mScrollbarActivity->ActivityStopped();
|
|
}
|
|
}
|
|
|
|
nsresult nsHTMLScrollFrame::CreateAnonymousContent(
|
|
nsTArray<ContentInfo>& aElements) {
|
|
return mHelper.CreateAnonymousContent(aElements);
|
|
}
|
|
|
|
void nsHTMLScrollFrame::AppendAnonymousContentTo(
|
|
nsTArray<nsIContent*>& aElements, uint32_t aFilter) {
|
|
mHelper.AppendAnonymousContentTo(aElements, aFilter);
|
|
}
|
|
|
|
void nsHTMLScrollFrame::DestroyFrom(nsIFrame* aDestructRoot,
|
|
PostDestroyData& aPostDestroyData) {
|
|
DestroyAbsoluteFrames(aDestructRoot, aPostDestroyData);
|
|
mHelper.Destroy(aPostDestroyData);
|
|
nsContainerFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
|
|
}
|
|
|
|
void nsHTMLScrollFrame::SetInitialChildList(ChildListID aListID,
|
|
nsFrameList& aChildList) {
|
|
nsContainerFrame::SetInitialChildList(aListID, aChildList);
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
|
|
void nsHTMLScrollFrame::AppendFrames(ChildListID aListID,
|
|
nsFrameList& aFrameList) {
|
|
NS_ASSERTION(aListID == kPrincipalList, "Only main list supported");
|
|
mFrames.AppendFrames(nullptr, aFrameList);
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
|
|
void nsHTMLScrollFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
|
|
const nsLineList::iterator* aPrevFrameLine,
|
|
nsFrameList& aFrameList) {
|
|
NS_ASSERTION(aListID == kPrincipalList, "Only main list supported");
|
|
NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
|
|
"inserting after sibling frame with different parent");
|
|
mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
|
|
void nsHTMLScrollFrame::RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) {
|
|
NS_ASSERTION(aListID == kPrincipalList, "Only main list supported");
|
|
mFrames.DestroyFrame(aOldFrame);
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
|
|
/**
|
|
HTML scrolling implementation
|
|
|
|
All other things being equal, we prefer layouts with fewer scrollbars showing.
|
|
*/
|
|
|
|
namespace mozilla {
|
|
|
|
enum class ShowScrollbar : uint8_t {
|
|
Auto,
|
|
Always,
|
|
// Never is a misnomer. We can still get a scrollbar if we need to scroll the
|
|
// visual viewport inside the layout viewport. Thus this enum is best thought
|
|
// of as value used by layout, which does not know about the visual viewport.
|
|
// The visual viewport does not affect any layout sizes, so this is sound.
|
|
Never,
|
|
};
|
|
|
|
static ShowScrollbar ShouldShowScrollbar(StyleOverflow aOverflow) {
|
|
switch (aOverflow) {
|
|
case StyleOverflow::Scroll:
|
|
return ShowScrollbar::Always;
|
|
case StyleOverflow::Hidden:
|
|
return ShowScrollbar::Never;
|
|
default:
|
|
case StyleOverflow::Auto:
|
|
return ShowScrollbar::Auto;
|
|
}
|
|
}
|
|
|
|
struct MOZ_STACK_CLASS ScrollReflowInput {
|
|
const ReflowInput& mReflowInput;
|
|
nsBoxLayoutState mBoxState;
|
|
ShowScrollbar mHScrollbar;
|
|
// If the horizontal scrollbar is allowed (even if mHScrollbar ==
|
|
// ShowScrollbar::Never) provided that it is for scrolling the visual viewport
|
|
// inside the layout viewport only.
|
|
bool mHScrollbarAllowedForScrollingVVInsideLV = true;
|
|
ShowScrollbar mVScrollbar;
|
|
// If the vertical scrollbar is allowed (even if mVScrollbar ==
|
|
// ShowScrollbar::Never) provided that it is for scrolling the visual viewport
|
|
// inside the layout viewport only.
|
|
bool mVScrollbarAllowedForScrollingVVInsideLV = true;
|
|
nsMargin mComputedBorder;
|
|
|
|
// === Filled in by ReflowScrolledFrame ===
|
|
OverflowAreas mContentsOverflowAreas;
|
|
MOZ_INIT_OUTSIDE_CTOR
|
|
bool mReflowedContentsWithHScrollbar;
|
|
MOZ_INIT_OUTSIDE_CTOR
|
|
bool mReflowedContentsWithVScrollbar;
|
|
|
|
// === Filled in when TryLayout succeeds ===
|
|
// The size of the inside-border area
|
|
nsSize mInsideBorderSize;
|
|
// Whether we decided to show the horizontal scrollbar
|
|
MOZ_INIT_OUTSIDE_CTOR
|
|
bool mShowHScrollbar;
|
|
// Whether we decided to show the vertical scrollbar
|
|
MOZ_INIT_OUTSIDE_CTOR
|
|
bool mShowVScrollbar;
|
|
// If mShow(H|V)Scrollbar is true then
|
|
// mOnlyNeed(V|H)ScrollbarToScrollVVInsideLV indicates if the only reason we
|
|
// need that scrollbar is to scroll the visual viewport inside the layout
|
|
// viewport. These scrollbars are special in that even if they are layout
|
|
// scrollbars they do not take up any layout space.
|
|
bool mOnlyNeedHScrollbarToScrollVVInsideLV = false;
|
|
bool mOnlyNeedVScrollbarToScrollVVInsideLV = false;
|
|
|
|
ScrollReflowInput(nsIScrollableFrame* aFrame, const ReflowInput& aReflowInput)
|
|
: mReflowInput(aReflowInput),
|
|
// mBoxState is just used for scrollbars so we don't need to
|
|
// worry about the reflow depth here
|
|
mBoxState(aReflowInput.mFrame->PresContext(),
|
|
aReflowInput.mRenderingContext) {
|
|
ScrollStyles styles = aFrame->GetScrollStyles();
|
|
mHScrollbar = ShouldShowScrollbar(styles.mHorizontal);
|
|
mVScrollbar = ShouldShowScrollbar(styles.mVertical);
|
|
}
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
// XXXldb Can this go away?
|
|
static nsSize ComputeInsideBorderSize(ScrollReflowInput* aState,
|
|
const nsSize& aDesiredInsideBorderSize) {
|
|
// aDesiredInsideBorderSize is the frame size; i.e., it includes
|
|
// borders and padding (but the scrolled child doesn't have
|
|
// borders). The scrolled child has the same padding as us.
|
|
nscoord contentWidth = aState->mReflowInput.ComputedWidth();
|
|
if (contentWidth == NS_UNCONSTRAINEDSIZE) {
|
|
contentWidth = aDesiredInsideBorderSize.width -
|
|
aState->mReflowInput.ComputedPhysicalPadding().LeftRight();
|
|
}
|
|
nscoord contentHeight = aState->mReflowInput.ComputedHeight();
|
|
if (contentHeight == NS_UNCONSTRAINEDSIZE) {
|
|
contentHeight = aDesiredInsideBorderSize.height -
|
|
aState->mReflowInput.ComputedPhysicalPadding().TopBottom();
|
|
}
|
|
|
|
contentWidth = aState->mReflowInput.ApplyMinMaxWidth(contentWidth);
|
|
contentHeight = aState->mReflowInput.ApplyMinMaxHeight(contentHeight);
|
|
return nsSize(
|
|
contentWidth + aState->mReflowInput.ComputedPhysicalPadding().LeftRight(),
|
|
contentHeight +
|
|
aState->mReflowInput.ComputedPhysicalPadding().TopBottom());
|
|
}
|
|
|
|
static void GetScrollbarMetrics(nsBoxLayoutState& aState, nsIFrame* aBox,
|
|
nsSize* aMin, nsSize* aPref) {
|
|
NS_ASSERTION(aState.GetRenderingContext(),
|
|
"Must have rendering context in layout state for size "
|
|
"computations");
|
|
|
|
if (aMin) {
|
|
*aMin = aBox->GetXULMinSize(aState);
|
|
nsIFrame::AddXULMargin(aBox, *aMin);
|
|
if (aMin->width < 0) {
|
|
aMin->width = 0;
|
|
}
|
|
if (aMin->height < 0) {
|
|
aMin->height = 0;
|
|
}
|
|
}
|
|
|
|
if (aPref) {
|
|
*aPref = aBox->GetXULPrefSize(aState);
|
|
nsIFrame::AddXULMargin(aBox, *aPref);
|
|
if (aPref->width < 0) {
|
|
aPref->width = 0;
|
|
}
|
|
if (aPref->height < 0) {
|
|
aPref->height = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assuming that we know the metrics for our wrapped frame and
|
|
* whether the horizontal and/or vertical scrollbars are present,
|
|
* compute the resulting layout and return true if the layout is
|
|
* consistent. If the layout is consistent then we fill in the
|
|
* computed fields of the ScrollReflowInput.
|
|
*
|
|
* The layout is consistent when both scrollbars are showing if and only
|
|
* if they should be showing. A horizontal scrollbar should be showing if all
|
|
* following conditions are met:
|
|
* 1) the style is not HIDDEN
|
|
* 2) our inside-border height is at least the scrollbar height (i.e., the
|
|
* scrollbar fits vertically)
|
|
* 3) the style is SCROLL, or the kid's overflow-area XMost is
|
|
* greater than the scrollport width
|
|
*
|
|
* @param aForce if true, then we just assume the layout is consistent.
|
|
*/
|
|
bool nsHTMLScrollFrame::TryLayout(ScrollReflowInput* aState,
|
|
ReflowOutput* aKidMetrics,
|
|
bool aAssumeHScroll, bool aAssumeVScroll,
|
|
bool aForce) {
|
|
if ((aState->mVScrollbar == ShowScrollbar::Never && aAssumeVScroll) ||
|
|
(aState->mHScrollbar == ShowScrollbar::Never && aAssumeHScroll)) {
|
|
NS_ASSERTION(!aForce, "Shouldn't be forcing a hidden scrollbar to show!");
|
|
return false;
|
|
}
|
|
|
|
if (aAssumeVScroll != aState->mReflowedContentsWithVScrollbar ||
|
|
(aAssumeHScroll != aState->mReflowedContentsWithHScrollbar &&
|
|
ScrolledContentDependsOnHeight(aState))) {
|
|
if (aAssumeHScroll != aState->mReflowedContentsWithHScrollbar) {
|
|
nsLayoutUtils::MarkIntrinsicISizesDirtyIfDependentOnBSize(
|
|
mHelper.mScrolledFrame);
|
|
}
|
|
aKidMetrics->mOverflowAreas.Clear();
|
|
ROOT_SCROLLBAR_LOG(
|
|
"TryLayout reflowing scrolled frame with scrollbars h=%d, v=%d\n",
|
|
aAssumeHScroll, aAssumeVScroll);
|
|
ReflowScrolledFrame(aState, aAssumeHScroll, aAssumeVScroll, aKidMetrics);
|
|
}
|
|
|
|
nsSize vScrollbarMinSize(0, 0);
|
|
nsSize vScrollbarPrefSize(0, 0);
|
|
if (mHelper.mVScrollbarBox) {
|
|
GetScrollbarMetrics(aState->mBoxState, mHelper.mVScrollbarBox,
|
|
&vScrollbarMinSize, &vScrollbarPrefSize);
|
|
nsScrollbarFrame* scrollbar = do_QueryFrame(mHelper.mVScrollbarBox);
|
|
scrollbar->SetScrollbarMediatorContent(mContent);
|
|
}
|
|
nscoord vScrollbarDesiredWidth =
|
|
aAssumeVScroll ? vScrollbarPrefSize.width : 0;
|
|
|
|
nsSize hScrollbarMinSize(0, 0);
|
|
nsSize hScrollbarPrefSize(0, 0);
|
|
if (mHelper.mHScrollbarBox) {
|
|
GetScrollbarMetrics(aState->mBoxState, mHelper.mHScrollbarBox,
|
|
&hScrollbarMinSize, &hScrollbarPrefSize);
|
|
nsScrollbarFrame* scrollbar = do_QueryFrame(mHelper.mHScrollbarBox);
|
|
scrollbar->SetScrollbarMediatorContent(mContent);
|
|
}
|
|
|
|
nscoord hScrollbarDesiredHeight =
|
|
aAssumeHScroll ? hScrollbarPrefSize.height : 0;
|
|
|
|
// First, compute our inside-border size and scrollport size
|
|
// XXXldb Can we depend more on ComputeSize here?
|
|
nsSize kidSize = aState->mReflowInput.mStyleDisplay->IsContainSize()
|
|
? nsSize(0, 0)
|
|
: aKidMetrics->PhysicalSize();
|
|
nsSize desiredInsideBorderSize;
|
|
desiredInsideBorderSize.width = vScrollbarDesiredWidth + kidSize.width;
|
|
desiredInsideBorderSize.height = hScrollbarDesiredHeight + kidSize.height;
|
|
aState->mInsideBorderSize =
|
|
ComputeInsideBorderSize(aState, desiredInsideBorderSize);
|
|
|
|
nsSize layoutSize = mHelper.mIsUsingMinimumScaleSize
|
|
? mHelper.mMinimumScaleSize
|
|
: aState->mInsideBorderSize;
|
|
|
|
const nsSize scrollPortSize =
|
|
nsSize(std::max(0, layoutSize.width - vScrollbarDesiredWidth),
|
|
std::max(0, layoutSize.height - hScrollbarDesiredHeight));
|
|
if (mHelper.mIsUsingMinimumScaleSize) {
|
|
mHelper.mICBSize = nsSize(
|
|
std::max(0, aState->mInsideBorderSize.width - vScrollbarDesiredWidth),
|
|
std::max(0,
|
|
aState->mInsideBorderSize.height - hScrollbarDesiredHeight));
|
|
}
|
|
|
|
nsSize visualViewportSize = scrollPortSize;
|
|
ROOT_SCROLLBAR_LOG("TryLayout with VV %s\n",
|
|
ToString(visualViewportSize).c_str());
|
|
mozilla::PresShell* presShell = PresShell();
|
|
// Note: we check for a non-null MobileViepwortManager here, but ideally we
|
|
// should be able to drop that clause as well. It's just that in some cases
|
|
// with extension popups the composition size comes back as stale, because
|
|
// the content viewer is only resized after the popup contents are reflowed.
|
|
// That case also happens to have no APZ and no MVM, so we use that as a
|
|
// way to detect the scenario. Bug 1648669 tracks removing this clause.
|
|
if (mHelper.mIsRoot && presShell->GetMobileViewportManager()) {
|
|
visualViewportSize = nsLayoutUtils::CalculateCompositionSizeForFrame(
|
|
this, false, &layoutSize);
|
|
|
|
visualViewportSize = nsSize(
|
|
std::max(0, visualViewportSize.width - vScrollbarDesiredWidth),
|
|
std::max(0, visualViewportSize.height - hScrollbarDesiredHeight));
|
|
|
|
float resolution = presShell->GetResolution();
|
|
visualViewportSize.width /= resolution;
|
|
visualViewportSize.height /= resolution;
|
|
ROOT_SCROLLBAR_LOG("TryLayout now with VV %s\n",
|
|
ToString(visualViewportSize).c_str());
|
|
}
|
|
|
|
nsRect overflowRect = aState->mContentsOverflowAreas.ScrollableOverflow();
|
|
// If the content height expanded by the minimum-scale will be taller than
|
|
// the scrollable overflow area, we need to expand the area here to tell
|
|
// properly whether we need to render the overlay vertical scrollbar.
|
|
// NOTE: This expanded size should NOT be used for non-overley scrollbars
|
|
// cases since putting the vertical non-overlay scrollbar will make the
|
|
// content width narrow a little bit, which in turn the minimum scale value
|
|
// becomes a bit bigger than before, then the vertical scrollbar is no longer
|
|
// needed, which means the content width becomes the original width, then the
|
|
// minimum-scale is changed to the original one, and so forth.
|
|
if (mHelper.UsesOverlayScrollbars() && mHelper.mIsUsingMinimumScaleSize &&
|
|
mHelper.mMinimumScaleSize.height > overflowRect.YMost()) {
|
|
overflowRect.height +=
|
|
mHelper.mMinimumScaleSize.height - overflowRect.YMost();
|
|
}
|
|
nsRect scrolledRect =
|
|
mHelper.GetUnsnappedScrolledRectInternal(overflowRect, scrollPortSize);
|
|
ROOT_SCROLLBAR_LOG(
|
|
"TryLayout scrolledRect:%s overflowRect:%s scrollportSize:%s\n",
|
|
ToString(scrolledRect).c_str(), ToString(overflowRect).c_str(),
|
|
ToString(scrollPortSize).c_str());
|
|
nscoord oneDevPixel = aState->mBoxState.PresContext()->DevPixelsToAppUnits(1);
|
|
|
|
if (!aForce) {
|
|
nsSize sizeToCompare = visualViewportSize;
|
|
if (gfxPlatform::UseDesktopZoomingScrollbars()) {
|
|
sizeToCompare = scrollPortSize;
|
|
}
|
|
|
|
// If the style is HIDDEN then we already know that aAssumeHScroll is false
|
|
if (aState->mHScrollbar != ShowScrollbar::Never) {
|
|
bool wantHScrollbar =
|
|
aState->mHScrollbar == ShowScrollbar::Always ||
|
|
scrolledRect.XMost() >= sizeToCompare.width + oneDevPixel ||
|
|
scrolledRect.x <= -oneDevPixel;
|
|
// TODO(emilio): This should probably check this scrollbar's minimum size
|
|
// in both axes, for consistency?
|
|
if (aState->mHScrollbar == ShowScrollbar::Auto &&
|
|
scrollPortSize.width < hScrollbarMinSize.width) {
|
|
wantHScrollbar = false;
|
|
}
|
|
ROOT_SCROLLBAR_LOG("TryLayout wants H Scrollbar: %d =? %d\n",
|
|
wantHScrollbar, aAssumeHScroll);
|
|
if (wantHScrollbar != aAssumeHScroll) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If the style is HIDDEN then we already know that aAssumeVScroll is false
|
|
if (aState->mVScrollbar != ShowScrollbar::Never) {
|
|
bool wantVScrollbar =
|
|
aState->mVScrollbar == ShowScrollbar::Always ||
|
|
scrolledRect.YMost() >= sizeToCompare.height + oneDevPixel ||
|
|
scrolledRect.y <= -oneDevPixel;
|
|
// TODO(emilio): This should probably check this scrollbar's minimum size
|
|
// in both axes, for consistency?
|
|
if (aState->mVScrollbar == ShowScrollbar::Auto &&
|
|
scrollPortSize.height < vScrollbarMinSize.height) {
|
|
wantVScrollbar = false;
|
|
}
|
|
ROOT_SCROLLBAR_LOG("TryLayout wants V Scrollbar: %d =? %d\n",
|
|
wantVScrollbar, aAssumeVScroll);
|
|
if (wantVScrollbar != aAssumeVScroll) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
aState->mShowHScrollbar = aAssumeHScroll;
|
|
aState->mShowVScrollbar = aAssumeVScroll;
|
|
nsPoint scrollPortOrigin(aState->mComputedBorder.left,
|
|
aState->mComputedBorder.top);
|
|
if (!IsScrollbarOnRight()) {
|
|
nscoord vScrollbarActualWidth = layoutSize.width - scrollPortSize.width;
|
|
scrollPortOrigin.x += vScrollbarActualWidth;
|
|
}
|
|
mHelper.mScrollPort = nsRect(scrollPortOrigin, scrollPortSize);
|
|
|
|
if (mHelper.mIsRoot && gfxPlatform::UseDesktopZoomingScrollbars()) {
|
|
bool vvChanged = true;
|
|
// This loop can run at most twice since we can only add a scrollbar once.
|
|
// At this point we've already decided that this layout is consistent so we
|
|
// will return true. Scrollbars added here never take up layout space even
|
|
// if they are layout scrollbars so any changes made here will not make us
|
|
// return false.
|
|
while (vvChanged) {
|
|
vvChanged = false;
|
|
if (!aState->mShowHScrollbar &&
|
|
aState->mHScrollbarAllowedForScrollingVVInsideLV) {
|
|
if (mHelper.mScrollPort.width >=
|
|
visualViewportSize.width + oneDevPixel &&
|
|
visualViewportSize.width >= hScrollbarMinSize.width) {
|
|
vvChanged = true;
|
|
visualViewportSize.height -= hScrollbarPrefSize.height;
|
|
aState->mShowHScrollbar = true;
|
|
aState->mOnlyNeedHScrollbarToScrollVVInsideLV = true;
|
|
ROOT_SCROLLBAR_LOG("TryLayout added H scrollbar for VV, VV now %s\n",
|
|
ToString(visualViewportSize).c_str());
|
|
}
|
|
}
|
|
|
|
if (!aState->mShowVScrollbar &&
|
|
aState->mVScrollbarAllowedForScrollingVVInsideLV) {
|
|
if (mHelper.mScrollPort.height >=
|
|
visualViewportSize.height + oneDevPixel &&
|
|
visualViewportSize.height >= vScrollbarMinSize.height) {
|
|
vvChanged = true;
|
|
visualViewportSize.width -= vScrollbarPrefSize.width;
|
|
aState->mShowVScrollbar = true;
|
|
aState->mOnlyNeedVScrollbarToScrollVVInsideLV = true;
|
|
ROOT_SCROLLBAR_LOG("TryLayout added V scrollbar for VV, VV now %s\n",
|
|
ToString(visualViewportSize).c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// XXX Height/BSize mismatch needs to be addressed here; check the caller!
|
|
// Currently this will only behave as expected for horizontal writing modes.
|
|
// (See bug 1175509.)
|
|
bool nsHTMLScrollFrame::ScrolledContentDependsOnHeight(
|
|
ScrollReflowInput* aState) {
|
|
// Return true if ReflowScrolledFrame is going to do something different
|
|
// based on the presence of a horizontal scrollbar.
|
|
return mHelper.mScrolledFrame->HasAnyStateBits(
|
|
NS_FRAME_CONTAINS_RELATIVE_BSIZE |
|
|
NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE) ||
|
|
aState->mReflowInput.ComputedBSize() != NS_UNCONSTRAINEDSIZE ||
|
|
aState->mReflowInput.ComputedMinBSize() > 0 ||
|
|
aState->mReflowInput.ComputedMaxBSize() != NS_UNCONSTRAINEDSIZE;
|
|
}
|
|
|
|
void nsHTMLScrollFrame::ReflowScrolledFrame(ScrollReflowInput* aState,
|
|
bool aAssumeHScroll,
|
|
bool aAssumeVScroll,
|
|
ReflowOutput* aMetrics) {
|
|
WritingMode wm = mHelper.mScrolledFrame->GetWritingMode();
|
|
|
|
// these could be NS_UNCONSTRAINEDSIZE ... std::min arithmetic should
|
|
// be OK
|
|
LogicalMargin padding = aState->mReflowInput.ComputedLogicalPadding(wm);
|
|
nscoord availISize =
|
|
aState->mReflowInput.ComputedISize() + padding.IStartEnd(wm);
|
|
|
|
nscoord computedBSize = aState->mReflowInput.ComputedBSize();
|
|
nscoord computedMinBSize = aState->mReflowInput.ComputedMinBSize();
|
|
nscoord computedMaxBSize = aState->mReflowInput.ComputedMaxBSize();
|
|
if (!ShouldPropagateComputedBSizeToScrolledContent()) {
|
|
computedBSize = NS_UNCONSTRAINEDSIZE;
|
|
computedMinBSize = 0;
|
|
computedMaxBSize = NS_UNCONSTRAINEDSIZE;
|
|
}
|
|
|
|
if (wm.IsVertical()) {
|
|
if (aAssumeVScroll) {
|
|
nsSize vScrollbarPrefSize;
|
|
GetScrollbarMetrics(aState->mBoxState, mHelper.mVScrollbarBox, nullptr,
|
|
&vScrollbarPrefSize);
|
|
if (computedBSize != NS_UNCONSTRAINEDSIZE) {
|
|
computedBSize = std::max(0, computedBSize - vScrollbarPrefSize.width);
|
|
}
|
|
computedMinBSize =
|
|
std::max(0, computedMinBSize - vScrollbarPrefSize.width);
|
|
if (computedMaxBSize != NS_UNCONSTRAINEDSIZE) {
|
|
computedMaxBSize =
|
|
std::max(0, computedMaxBSize - vScrollbarPrefSize.width);
|
|
}
|
|
}
|
|
|
|
if (aAssumeHScroll) {
|
|
nsSize hScrollbarPrefSize;
|
|
GetScrollbarMetrics(aState->mBoxState, mHelper.mHScrollbarBox, nullptr,
|
|
&hScrollbarPrefSize);
|
|
availISize = std::max(0, availISize - hScrollbarPrefSize.height);
|
|
}
|
|
} else {
|
|
if (aAssumeHScroll) {
|
|
nsSize hScrollbarPrefSize;
|
|
GetScrollbarMetrics(aState->mBoxState, mHelper.mHScrollbarBox, nullptr,
|
|
&hScrollbarPrefSize);
|
|
if (computedBSize != NS_UNCONSTRAINEDSIZE) {
|
|
computedBSize = std::max(0, computedBSize - hScrollbarPrefSize.height);
|
|
}
|
|
computedMinBSize =
|
|
std::max(0, computedMinBSize - hScrollbarPrefSize.height);
|
|
if (computedMaxBSize != NS_UNCONSTRAINEDSIZE) {
|
|
computedMaxBSize =
|
|
std::max(0, computedMaxBSize - hScrollbarPrefSize.height);
|
|
}
|
|
}
|
|
|
|
if (aAssumeVScroll) {
|
|
nsSize vScrollbarPrefSize;
|
|
GetScrollbarMetrics(aState->mBoxState, mHelper.mVScrollbarBox, nullptr,
|
|
&vScrollbarPrefSize);
|
|
availISize = std::max(0, availISize - vScrollbarPrefSize.width);
|
|
}
|
|
}
|
|
|
|
nsPresContext* presContext = PresContext();
|
|
|
|
// Pass InitFlags::CallerWillInit so we can pass in the correct padding.
|
|
ReflowInput kidReflowInput(presContext, aState->mReflowInput,
|
|
mHelper.mScrolledFrame,
|
|
LogicalSize(wm, availISize, NS_UNCONSTRAINEDSIZE),
|
|
Nothing(), ReflowInput::InitFlag::CallerWillInit);
|
|
const WritingMode kidWM = kidReflowInput.GetWritingMode();
|
|
kidReflowInput.Init(presContext, Nothing(), Nothing(),
|
|
Some(padding.ConvertTo(kidWM, wm)));
|
|
kidReflowInput.mFlags.mAssumingHScrollbar = aAssumeHScroll;
|
|
kidReflowInput.mFlags.mAssumingVScrollbar = aAssumeVScroll;
|
|
kidReflowInput.SetComputedBSize(computedBSize);
|
|
kidReflowInput.ComputedMinBSize() = computedMinBSize;
|
|
kidReflowInput.ComputedMaxBSize() = computedMaxBSize;
|
|
if (aState->mReflowInput.IsBResizeForWM(kidWM)) {
|
|
kidReflowInput.SetBResize(true);
|
|
}
|
|
if (aState->mReflowInput.IsBResizeForPercentagesForWM(kidWM)) {
|
|
kidReflowInput.mFlags.mIsBResizeForPercentages = true;
|
|
}
|
|
|
|
// Temporarily set mHasHorizontalScrollbar/mHasVerticalScrollbar to
|
|
// reflect our assumptions while we reflow the child.
|
|
bool didHaveHorizontalScrollbar = mHelper.mHasHorizontalScrollbar;
|
|
bool didHaveVerticalScrollbar = mHelper.mHasVerticalScrollbar;
|
|
mHelper.mHasHorizontalScrollbar = aAssumeHScroll;
|
|
mHelper.mHasVerticalScrollbar = aAssumeVScroll;
|
|
|
|
nsReflowStatus status;
|
|
// No need to pass a true container-size to ReflowChild or
|
|
// FinishReflowChild, because it's only used there when positioning
|
|
// the frame (i.e. if ReflowChildFlags::NoMoveFrame isn't set)
|
|
const nsSize dummyContainerSize;
|
|
ReflowChild(mHelper.mScrolledFrame, presContext, *aMetrics, kidReflowInput,
|
|
wm, LogicalPoint(wm), dummyContainerSize,
|
|
ReflowChildFlags::NoMoveFrame, status);
|
|
|
|
mHelper.mHasHorizontalScrollbar = didHaveHorizontalScrollbar;
|
|
mHelper.mHasVerticalScrollbar = didHaveVerticalScrollbar;
|
|
|
|
// Don't resize or position the view (if any) because we're going to resize
|
|
// it to the correct size anyway in PlaceScrollArea. Allowing it to
|
|
// resize here would size it to the natural height of the frame,
|
|
// which will usually be different from the scrollport height;
|
|
// invalidating the difference will cause unnecessary repainting.
|
|
FinishReflowChild(
|
|
mHelper.mScrolledFrame, presContext, *aMetrics, &kidReflowInput, wm,
|
|
LogicalPoint(wm), dummyContainerSize,
|
|
ReflowChildFlags::NoMoveFrame | ReflowChildFlags::NoSizeView);
|
|
|
|
// XXX Some frames (e.g. nsFrameFrame, nsTextFrame) don't
|
|
// bother setting their mOverflowArea. This is wrong because every frame
|
|
// should always set mOverflowArea. In fact nsFrameFrame doesn't
|
|
// support the 'outline' property because of this. Rather than fix the
|
|
// world right now, just fix up the overflow area if necessary. Note that we
|
|
// don't check HasOverflowRect() because it could be set even though the
|
|
// overflow area doesn't include the frame bounds.
|
|
aMetrics->UnionOverflowAreasWithDesiredBounds();
|
|
|
|
auto* disp = StyleDisplay();
|
|
if (MOZ_UNLIKELY(disp->mOverflowClipBoxInline ==
|
|
StyleOverflowClipBox::ContentBox)) {
|
|
// If the scrolled frame can be scrolled in the inline axis, inflate its
|
|
// scrollable overflow areas with its inline-end padding to prevent its
|
|
// content from being clipped at scroll container's inline-end padding
|
|
// edge.
|
|
//
|
|
// Note: Inflating scrolled frame's overflow areas is generally wrong if the
|
|
// scrolled frame's children themselves has any scrollable overflow areas.
|
|
// However, we can only be here in production for <textarea> and <input>.
|
|
// Both elements can only have text children, which shouldn't have
|
|
// scrollable overflow areas themselves, so its fine.
|
|
nsRect& so = aMetrics->ScrollableOverflow();
|
|
const nscoord soInlineSize = wm.IsVertical() ? so.Height() : so.Width();
|
|
if (soInlineSize > availISize) {
|
|
const LogicalMargin inlinePaddingEnd =
|
|
padding.ApplySkipSides(LogicalSides(wm, eLogicalSideBitsBBoth) |
|
|
LogicalSides(wm, eLogicalSideBitsIStart));
|
|
so.Inflate(inlinePaddingEnd.GetPhysicalMargin(wm));
|
|
}
|
|
}
|
|
|
|
aState->mContentsOverflowAreas = aMetrics->mOverflowAreas;
|
|
aState->mReflowedContentsWithHScrollbar = aAssumeHScroll;
|
|
aState->mReflowedContentsWithVScrollbar = aAssumeVScroll;
|
|
}
|
|
|
|
bool nsHTMLScrollFrame::GuessHScrollbarNeeded(const ScrollReflowInput& aState) {
|
|
if (aState.mHScrollbar != ShowScrollbar::Auto) {
|
|
// no guessing required
|
|
return aState.mHScrollbar == ShowScrollbar::Always;
|
|
}
|
|
// We only care about scrollbars that might take up space when trying to guess
|
|
// if we need a scrollbar, so we ignore scrollbars only created to scroll the
|
|
// visual viewport inside the layout viewport because they take up no layout
|
|
// space.
|
|
return mHelper.mHasHorizontalScrollbar &&
|
|
!mHelper.mOnlyNeedHScrollbarToScrollVVInsideLV;
|
|
}
|
|
|
|
bool nsHTMLScrollFrame::GuessVScrollbarNeeded(const ScrollReflowInput& aState) {
|
|
if (aState.mVScrollbar != ShowScrollbar::Auto) {
|
|
// no guessing required
|
|
return aState.mVScrollbar == ShowScrollbar::Always;
|
|
}
|
|
|
|
// If we've had at least one non-initial reflow, then just assume
|
|
// the state of the vertical scrollbar will be what we determined
|
|
// last time.
|
|
if (mHelper.mHadNonInitialReflow) {
|
|
// We only care about scrollbars that might take up space when trying to
|
|
// guess if we need a scrollbar, so we ignore scrollbars only created to
|
|
// scroll the visual viewport inside the layout viewport because they take
|
|
// up no layout space.
|
|
return mHelper.mHasVerticalScrollbar &&
|
|
!mHelper.mOnlyNeedVScrollbarToScrollVVInsideLV;
|
|
}
|
|
|
|
// If this is the initial reflow, guess false because usually
|
|
// we have very little content by then.
|
|
if (InInitialReflow()) return false;
|
|
|
|
if (mHelper.mIsRoot) {
|
|
nsIFrame* f = mHelper.mScrolledFrame->PrincipalChildList().FirstChild();
|
|
if (f && f->IsSVGOuterSVGFrame() &&
|
|
static_cast<SVGOuterSVGFrame*>(f)->VerticalScrollbarNotNeeded()) {
|
|
// Common SVG case - avoid a bad guess.
|
|
return false;
|
|
}
|
|
// Assume that there will be a scrollbar; it seems to me
|
|
// that 'most pages' do have a scrollbar, and anyway, it's cheaper
|
|
// to do an extra reflow for the pages that *don't* need a
|
|
// scrollbar (because on average they will have less content).
|
|
return true;
|
|
}
|
|
|
|
// For non-viewports, just guess that we don't need a scrollbar.
|
|
// XXX I wonder if statistically this is the right idea; I'm
|
|
// basically guessing that there are a lot of overflow:auto DIVs
|
|
// that get their intrinsic size and don't overflow
|
|
return false;
|
|
}
|
|
|
|
bool nsHTMLScrollFrame::InInitialReflow() const {
|
|
// We're in an initial reflow if NS_FRAME_FIRST_REFLOW is set, unless we're a
|
|
// root scrollframe. In that case we want to skip this clause altogether.
|
|
// The guess here is that there are lots of overflow:auto divs out there that
|
|
// end up auto-sizing so they don't overflow, and that the root basically
|
|
// always needs a scrollbar if it did last time we loaded this page (good
|
|
// assumption, because our initial reflow is no longer synchronous).
|
|
return !mHelper.mIsRoot && HasAnyStateBits(NS_FRAME_FIRST_REFLOW);
|
|
}
|
|
|
|
void nsHTMLScrollFrame::ReflowContents(ScrollReflowInput* aState,
|
|
const ReflowOutput& aDesiredSize) {
|
|
ReflowOutput kidDesiredSize(aDesiredSize.GetWritingMode());
|
|
ReflowScrolledFrame(aState, GuessHScrollbarNeeded(*aState),
|
|
GuessVScrollbarNeeded(*aState), &kidDesiredSize);
|
|
|
|
// There's an important special case ... if the child appears to fit
|
|
// in the inside-border rect (but overflows the scrollport), we
|
|
// should try laying it out without a vertical scrollbar. It will
|
|
// usually fit because making the available-width wider will not
|
|
// normally make the child taller. (The only situation I can think
|
|
// of is when you have a line containing %-width inline replaced
|
|
// elements whose percentages sum to more than 100%, so increasing
|
|
// the available width makes the line break where it was fitting
|
|
// before.) If we don't treat this case specially, then we will
|
|
// decide that showing scrollbars is OK because the content
|
|
// overflows when we're showing scrollbars and we won't try to
|
|
// remove the vertical scrollbar.
|
|
|
|
// Detecting when we enter this special case is important for when
|
|
// people design layouts that exactly fit the container "most of the
|
|
// time".
|
|
|
|
// XXX Is this check really sufficient to catch all the incremental cases
|
|
// where the ideal case doesn't have a scrollbar?
|
|
if ((aState->mReflowedContentsWithHScrollbar ||
|
|
aState->mReflowedContentsWithVScrollbar) &&
|
|
aState->mVScrollbar != ShowScrollbar::Always &&
|
|
aState->mHScrollbar != ShowScrollbar::Always) {
|
|
nsSize kidSize = aState->mReflowInput.mStyleDisplay->IsContainSize()
|
|
? nsSize(0, 0)
|
|
: kidDesiredSize.PhysicalSize();
|
|
nsSize insideBorderSize = ComputeInsideBorderSize(aState, kidSize);
|
|
nsRect scrolledRect = mHelper.GetUnsnappedScrolledRectInternal(
|
|
kidDesiredSize.ScrollableOverflow(), insideBorderSize);
|
|
if (nsRect(nsPoint(0, 0), insideBorderSize).Contains(scrolledRect)) {
|
|
// Let's pretend we had no scrollbars coming in here
|
|
kidDesiredSize.mOverflowAreas.Clear();
|
|
ReflowScrolledFrame(aState, false, false, &kidDesiredSize);
|
|
}
|
|
}
|
|
|
|
if (IsRootScrollFrameOfDocument()) {
|
|
mHelper.UpdateMinimumScaleSize(
|
|
aState->mContentsOverflowAreas.ScrollableOverflow(),
|
|
kidDesiredSize.PhysicalSize());
|
|
}
|
|
|
|
// Try vertical scrollbar settings that leave the vertical scrollbar
|
|
// unchanged. Do this first because changing the vertical scrollbar setting is
|
|
// expensive, forcing a reflow always.
|
|
|
|
// Try leaving the horizontal scrollbar unchanged first. This will be more
|
|
// efficient.
|
|
ROOT_SCROLLBAR_LOG("Trying layout1 with %d, %d\n",
|
|
aState->mReflowedContentsWithHScrollbar,
|
|
aState->mReflowedContentsWithVScrollbar);
|
|
if (TryLayout(aState, &kidDesiredSize,
|
|
aState->mReflowedContentsWithHScrollbar,
|
|
aState->mReflowedContentsWithVScrollbar, false))
|
|
return;
|
|
ROOT_SCROLLBAR_LOG("Trying layout2 with %d, %d\n",
|
|
!aState->mReflowedContentsWithHScrollbar,
|
|
aState->mReflowedContentsWithVScrollbar);
|
|
if (TryLayout(aState, &kidDesiredSize,
|
|
!aState->mReflowedContentsWithHScrollbar,
|
|
aState->mReflowedContentsWithVScrollbar, false))
|
|
return;
|
|
|
|
// OK, now try toggling the vertical scrollbar. The performance advantage
|
|
// of trying the status-quo horizontal scrollbar state
|
|
// does not exist here (we'll have to reflow due to the vertical scrollbar
|
|
// change), so always try no horizontal scrollbar first.
|
|
bool newVScrollbarState = !aState->mReflowedContentsWithVScrollbar;
|
|
ROOT_SCROLLBAR_LOG("Trying layout3 with %d, %d\n", false, newVScrollbarState);
|
|
if (TryLayout(aState, &kidDesiredSize, false, newVScrollbarState, false))
|
|
return;
|
|
ROOT_SCROLLBAR_LOG("Trying layout4 with %d, %d\n", true, newVScrollbarState);
|
|
if (TryLayout(aState, &kidDesiredSize, true, newVScrollbarState, false))
|
|
return;
|
|
|
|
// OK, we're out of ideas. Try again enabling whatever scrollbars we can
|
|
// enable and force the layout to stick even if it's inconsistent.
|
|
// This just happens sometimes.
|
|
ROOT_SCROLLBAR_LOG("Giving up, adding both scrollbars...\n");
|
|
TryLayout(aState, &kidDesiredSize,
|
|
aState->mHScrollbar != ShowScrollbar::Never,
|
|
aState->mVScrollbar != ShowScrollbar::Never, true);
|
|
}
|
|
|
|
void nsHTMLScrollFrame::PlaceScrollArea(ScrollReflowInput& aState,
|
|
const nsPoint& aScrollPosition) {
|
|
nsIFrame* scrolledFrame = mHelper.mScrolledFrame;
|
|
// Set the x,y of the scrolled frame to the correct value
|
|
scrolledFrame->SetPosition(mHelper.mScrollPort.TopLeft() - aScrollPosition);
|
|
|
|
// Recompute our scrollable overflow, taking perspective children into
|
|
// account. Note that this only recomputes the overflow areas stored on the
|
|
// helper (which are used to compute scrollable length and scrollbar thumb
|
|
// sizes) but not the overflow areas stored on the frame. This seems to work
|
|
// for now, but it's possible that we may need to update both in the future.
|
|
AdjustForPerspective(aState.mContentsOverflowAreas.ScrollableOverflow());
|
|
|
|
// Preserve the width or height of empty rects
|
|
nsSize portSize = mHelper.mScrollPort.Size();
|
|
nsRect scrolledRect = mHelper.GetUnsnappedScrolledRectInternal(
|
|
aState.mContentsOverflowAreas.ScrollableOverflow(), portSize);
|
|
nsRect scrolledArea =
|
|
scrolledRect.UnionEdges(nsRect(nsPoint(0, 0), portSize));
|
|
|
|
// Store the new overflow area. Note that this changes where an outline
|
|
// of the scrolled frame would be painted, but scrolled frames can't have
|
|
// outlines (the outline would go on this scrollframe instead).
|
|
// Using FinishAndStoreOverflow is needed so the overflow rect gets set
|
|
// correctly. It also messes with the overflow rect in the 'clip' case, but
|
|
// scrolled frames can't have 'overflow' either.
|
|
// This needs to happen before SyncFrameViewAfterReflow so
|
|
// HasOverflowRect() will return the correct value.
|
|
OverflowAreas overflow(scrolledArea, scrolledArea);
|
|
scrolledFrame->FinishAndStoreOverflow(overflow, scrolledFrame->GetSize());
|
|
|
|
// Note that making the view *exactly* the size of the scrolled area
|
|
// is critical, since the view scrolling code uses the size of the
|
|
// scrolled view to clamp scroll requests.
|
|
// Normally the scrolledFrame won't have a view but in some cases it
|
|
// might create its own.
|
|
nsContainerFrame::SyncFrameViewAfterReflow(
|
|
scrolledFrame->PresContext(), scrolledFrame, scrolledFrame->GetView(),
|
|
scrolledArea, ReflowChildFlags::Default);
|
|
}
|
|
|
|
nscoord nsHTMLScrollFrame::GetIntrinsicVScrollbarWidth(
|
|
gfxContext* aRenderingContext) {
|
|
ScrollStyles ss = GetScrollStyles();
|
|
if (ss.mVertical != StyleOverflow::Scroll || !mHelper.mVScrollbarBox)
|
|
return 0;
|
|
|
|
// Don't need to worry about reflow depth here since it's
|
|
// just for scrollbars
|
|
nsBoxLayoutState bls(PresContext(), aRenderingContext, 0);
|
|
nsSize vScrollbarPrefSize(0, 0);
|
|
GetScrollbarMetrics(bls, mHelper.mVScrollbarBox, nullptr,
|
|
&vScrollbarPrefSize);
|
|
return vScrollbarPrefSize.width;
|
|
}
|
|
|
|
// Legacy, this sucks!
|
|
static bool IsMarqueeScrollbox(const nsIFrame& aScrollFrame) {
|
|
if (!aScrollFrame.GetContent()) {
|
|
return false;
|
|
}
|
|
if (MOZ_LIKELY(!aScrollFrame.GetContent()->IsInUAWidget())) {
|
|
return false;
|
|
}
|
|
MOZ_ASSERT(aScrollFrame.GetParent() &&
|
|
aScrollFrame.GetParent()->GetContent());
|
|
return aScrollFrame.GetParent() &&
|
|
HTMLMarqueeElement::FromNodeOrNull(
|
|
aScrollFrame.GetParent()->GetContent());
|
|
}
|
|
|
|
/* virtual */
|
|
nscoord nsHTMLScrollFrame::GetMinISize(gfxContext* aRenderingContext) {
|
|
nscoord result = [&] {
|
|
if (StyleDisplay()->IsContainSize()) {
|
|
return 0;
|
|
}
|
|
if (MOZ_UNLIKELY(IsMarqueeScrollbox(*this))) {
|
|
return 0;
|
|
}
|
|
return mHelper.mScrolledFrame->GetMinISize(aRenderingContext);
|
|
}();
|
|
|
|
DISPLAY_MIN_INLINE_SIZE(this, result);
|
|
return result + GetIntrinsicVScrollbarWidth(aRenderingContext);
|
|
}
|
|
|
|
/* virtual */
|
|
nscoord nsHTMLScrollFrame::GetPrefISize(gfxContext* aRenderingContext) {
|
|
nscoord result =
|
|
StyleDisplay()->IsContainSize()
|
|
? 0
|
|
: mHelper.mScrolledFrame->GetPrefISize(aRenderingContext);
|
|
DISPLAY_PREF_INLINE_SIZE(this, result);
|
|
return NSCoordSaturatingAdd(result,
|
|
GetIntrinsicVScrollbarWidth(aRenderingContext));
|
|
}
|
|
|
|
nsresult nsHTMLScrollFrame::GetXULPadding(nsMargin& aMargin) {
|
|
// Our padding hangs out on the inside of the scrollframe, but XUL doesn't
|
|
// reaize that. If we're stuck inside a XUL box, we need to claim no
|
|
// padding.
|
|
// @see also nsXULScrollFrame::GetXULPadding.
|
|
aMargin.SizeTo(0, 0, 0, 0);
|
|
return NS_OK;
|
|
}
|
|
|
|
bool nsHTMLScrollFrame::IsXULCollapsed() {
|
|
// We're never collapsed in the box sense.
|
|
return false;
|
|
}
|
|
|
|
// When we have perspective set on the outer scroll frame, and transformed
|
|
// children (possibly with preserve-3d) then the effective transform on the
|
|
// child depends on the offset to the scroll frame, which changes as we scroll.
|
|
// This perspective transform can cause the element to move relative to the
|
|
// scrolled inner frame, which would cause the scrollable length changes during
|
|
// scrolling if we didn't account for it. Since we don't want scrollHeight/Width
|
|
// and the size of scrollbar thumbs to change during scrolling, we compute the
|
|
// scrollable overflow by determining the scroll position at which the child
|
|
// becomes completely visible within the scrollport rather than using the union
|
|
// of the overflow areas at their current position.
|
|
static void GetScrollableOverflowForPerspective(
|
|
nsIFrame* aScrolledFrame, nsIFrame* aCurrentFrame, const nsRect aScrollPort,
|
|
nsPoint aOffset, nsRect& aScrolledFrameOverflowArea) {
|
|
// Iterate over all children except pop-ups.
|
|
FrameChildListIDs skip = {nsIFrame::kSelectPopupList, nsIFrame::kPopupList};
|
|
for (const auto& [list, listID] : aCurrentFrame->ChildLists()) {
|
|
if (skip.contains(listID)) {
|
|
continue;
|
|
}
|
|
|
|
for (nsIFrame* child : list) {
|
|
nsPoint offset = aOffset;
|
|
|
|
// When we reach a direct child of the scroll, then we record the offset
|
|
// to convert from that frame's coordinate into the scroll frame's
|
|
// coordinates. Preserve-3d descendant frames use the same offset as their
|
|
// ancestors, since TransformRect already converts us into the coordinate
|
|
// space of the preserve-3d root.
|
|
if (aScrolledFrame == aCurrentFrame) {
|
|
offset = child->GetPosition();
|
|
}
|
|
|
|
if (child->Extend3DContext()) {
|
|
// If we're a preserve-3d frame, then recurse and include our
|
|
// descendants since overflow of preserve-3d frames is only included
|
|
// in the post-transform overflow area of the preserve-3d root frame.
|
|
GetScrollableOverflowForPerspective(aScrolledFrame, child, aScrollPort,
|
|
offset, aScrolledFrameOverflowArea);
|
|
}
|
|
|
|
// If we're transformed, then we want to consider the possibility that
|
|
// this frame might move relative to the scrolled frame when scrolling.
|
|
// For preserve-3d, leaf frames have correct overflow rects relative to
|
|
// themselves. preserve-3d 'nodes' (intermediate frames and the root) have
|
|
// only their untransformed children included in their overflow relative
|
|
// to self, which is what we want to include here.
|
|
if (child->IsTransformed()) {
|
|
// Compute the overflow rect for this leaf transform frame in the
|
|
// coordinate space of the scrolled frame.
|
|
nsPoint scrollPos = aScrolledFrame->GetPosition();
|
|
nsRect preScroll, postScroll;
|
|
{
|
|
// TODO: Can we reuse the reference box?
|
|
TransformReferenceBox refBox(child);
|
|
preScroll = nsDisplayTransform::TransformRect(
|
|
child->ScrollableOverflowRectRelativeToSelf(), child, refBox);
|
|
}
|
|
|
|
// Temporarily override the scroll position of the scrolled frame by
|
|
// 10 CSS pixels, and then recompute what the overflow rect would be.
|
|
// This scroll position may not be valid, but that shouldn't matter
|
|
// for our calculations.
|
|
{
|
|
aScrolledFrame->SetPosition(scrollPos + nsPoint(600, 600));
|
|
TransformReferenceBox refBox(child);
|
|
postScroll = nsDisplayTransform::TransformRect(
|
|
child->ScrollableOverflowRectRelativeToSelf(), child, refBox);
|
|
aScrolledFrame->SetPosition(scrollPos);
|
|
}
|
|
|
|
// Compute how many app units the overflow rects moves by when we adjust
|
|
// the scroll position by 1 app unit.
|
|
double rightDelta =
|
|
(postScroll.XMost() - preScroll.XMost() + 600.0) / 600.0;
|
|
double bottomDelta =
|
|
(postScroll.YMost() - preScroll.YMost() + 600.0) / 600.0;
|
|
|
|
// We can't ever have negative scrolling.
|
|
NS_ASSERTION(rightDelta > 0.0f && bottomDelta > 0.0f,
|
|
"Scrolling can't be reversed!");
|
|
|
|
// Move preScroll into the coordinate space of the scrollport.
|
|
preScroll += offset + scrollPos;
|
|
|
|
// For each of the four edges of preScroll, figure out how far they
|
|
// extend beyond the scrollport. Ignore negative values since that means
|
|
// that side is already scrolled in to view and we don't need to add
|
|
// overflow to account for it.
|
|
nsMargin overhang(std::max(0, aScrollPort.Y() - preScroll.Y()),
|
|
std::max(0, preScroll.XMost() - aScrollPort.XMost()),
|
|
std::max(0, preScroll.YMost() - aScrollPort.YMost()),
|
|
std::max(0, aScrollPort.X() - preScroll.X()));
|
|
|
|
// Scale according to rightDelta/bottomDelta to adjust for the different
|
|
// scroll rates.
|
|
overhang.top /= bottomDelta;
|
|
overhang.right /= rightDelta;
|
|
overhang.bottom /= bottomDelta;
|
|
overhang.left /= rightDelta;
|
|
|
|
// Take the minimum overflow rect that would allow the current scroll
|
|
// position, using the size of the scroll port and offset by the
|
|
// inverse of the scroll position.
|
|
nsRect overflow = aScrollPort - scrollPos;
|
|
|
|
// Expand it by our margins to get an overflow rect that would allow all
|
|
// edges of our transformed content to be scrolled into view.
|
|
overflow.Inflate(overhang);
|
|
|
|
// Merge it with the combined overflow
|
|
aScrolledFrameOverflowArea.UnionRect(aScrolledFrameOverflowArea,
|
|
overflow);
|
|
} else if (aCurrentFrame == aScrolledFrame) {
|
|
aScrolledFrameOverflowArea.UnionRect(
|
|
aScrolledFrameOverflowArea,
|
|
child->ScrollableOverflowRectRelativeToParent());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
nscoord nsHTMLScrollFrame::GetLogicalBaseline(WritingMode aWritingMode) const {
|
|
// This function implements some of the spec text here:
|
|
// https://drafts.csswg.org/css-align/#baseline-export
|
|
//
|
|
// Specifically: if our scrolled frame is a block, we just use the inherited
|
|
// GetLogicalBaseline() impl, which synthesizes a baseline from the
|
|
// margin-box. Otherwise, we defer to our scrolled frame, considering it
|
|
// to be scrolled to its initial scroll position.
|
|
if (mHelper.mScrolledFrame->IsBlockFrameOrSubclass() ||
|
|
StyleDisplay()->IsContainLayout()) {
|
|
return nsContainerFrame::GetLogicalBaseline(aWritingMode);
|
|
}
|
|
|
|
// OK, here's where we defer to our scrolled frame. We have to add our
|
|
// border BStart thickness to whatever it returns, to produce an offset in
|
|
// our frame-rect's coordinate system. (We don't have to add padding,
|
|
// because the scrolled frame handles our padding.)
|
|
LogicalMargin border = GetLogicalUsedBorder(aWritingMode);
|
|
|
|
return border.BStart(aWritingMode) +
|
|
mHelper.mScrolledFrame->GetLogicalBaseline(aWritingMode);
|
|
}
|
|
|
|
void nsHTMLScrollFrame::AdjustForPerspective(nsRect& aScrollableOverflow) {
|
|
// If we have perspective that is being applied to our children, then
|
|
// the effective transform on the child depends on the relative position
|
|
// of the child to us and changes during scrolling.
|
|
if (!ChildrenHavePerspective()) {
|
|
return;
|
|
}
|
|
aScrollableOverflow.SetEmpty();
|
|
GetScrollableOverflowForPerspective(
|
|
mHelper.mScrolledFrame, mHelper.mScrolledFrame, mHelper.mScrollPort,
|
|
nsPoint(), aScrollableOverflow);
|
|
}
|
|
|
|
void nsHTMLScrollFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus) {
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsHTMLScrollFrame");
|
|
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
|
|
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
|
|
|
|
mHelper.HandleScrollbarStyleSwitching();
|
|
|
|
ScrollReflowInput state(this, aReflowInput);
|
|
// sanity check: ensure that if we have no scrollbar, we treat it
|
|
// as hidden.
|
|
if (!mHelper.mVScrollbarBox || mHelper.mNeverHasVerticalScrollbar) {
|
|
state.mVScrollbarAllowedForScrollingVVInsideLV = false;
|
|
state.mVScrollbar = ShowScrollbar::Never;
|
|
}
|
|
if (!mHelper.mHScrollbarBox || mHelper.mNeverHasHorizontalScrollbar) {
|
|
state.mHScrollbarAllowedForScrollingVVInsideLV = false;
|
|
state.mHScrollbar = ShowScrollbar::Never;
|
|
}
|
|
|
|
//------------ Handle Incremental Reflow -----------------
|
|
bool reflowHScrollbar = true;
|
|
bool reflowVScrollbar = true;
|
|
bool reflowScrollCorner = true;
|
|
if (!aReflowInput.ShouldReflowAllKids()) {
|
|
#define NEEDS_REFLOW(frame_) ((frame_) && (frame_)->IsSubtreeDirty())
|
|
|
|
reflowHScrollbar = NEEDS_REFLOW(mHelper.mHScrollbarBox);
|
|
reflowVScrollbar = NEEDS_REFLOW(mHelper.mVScrollbarBox);
|
|
reflowScrollCorner = NEEDS_REFLOW(mHelper.mScrollCornerBox) ||
|
|
NEEDS_REFLOW(mHelper.mResizerBox);
|
|
|
|
#undef NEEDS_REFLOW
|
|
}
|
|
|
|
if (mHelper.mIsRoot) {
|
|
reflowScrollCorner = false;
|
|
|
|
// Hide the scrollbar when the scrollbar-width is set to none.
|
|
// This is only needed for root element because scrollbars of non-
|
|
// root elements with "scrollbar-width: none" is already suppressed
|
|
// in ScrollFrameHelper::CreateAnonymousContent.
|
|
ComputedStyle* scrollbarStyle = nsLayoutUtils::StyleForScrollbar(this);
|
|
auto scrollbarWidth = scrollbarStyle->StyleUIReset()->mScrollbarWidth;
|
|
if (scrollbarWidth == StyleScrollbarWidth::None) {
|
|
state.mVScrollbarAllowedForScrollingVVInsideLV = false;
|
|
state.mHScrollbarAllowedForScrollingVVInsideLV = false;
|
|
state.mVScrollbar = ShowScrollbar::Never;
|
|
state.mHScrollbar = ShowScrollbar::Never;
|
|
}
|
|
}
|
|
|
|
nsRect oldScrollAreaBounds = mHelper.mScrollPort;
|
|
nsRect oldScrolledAreaBounds =
|
|
mHelper.mScrolledFrame->ScrollableOverflowRectRelativeToParent();
|
|
nsPoint oldScrollPosition = mHelper.GetScrollPosition();
|
|
|
|
state.mComputedBorder = aReflowInput.ComputedPhysicalBorderPadding() -
|
|
aReflowInput.ComputedPhysicalPadding();
|
|
|
|
ReflowContents(&state, aDesiredSize);
|
|
|
|
nsSize layoutSize = mHelper.mIsUsingMinimumScaleSize
|
|
? mHelper.mMinimumScaleSize
|
|
: state.mInsideBorderSize;
|
|
aDesiredSize.Width() = layoutSize.width + state.mComputedBorder.LeftRight();
|
|
aDesiredSize.Height() = layoutSize.height + state.mComputedBorder.TopBottom();
|
|
|
|
// Set the size of the frame now since computing the perspective-correct
|
|
// overflow (within PlaceScrollArea) can rely on it.
|
|
SetSize(aDesiredSize.GetWritingMode(),
|
|
aDesiredSize.Size(aDesiredSize.GetWritingMode()));
|
|
|
|
// Restore the old scroll position, for now, even if that's not valid anymore
|
|
// because we changed size. We'll fix it up in a post-reflow callback, because
|
|
// our current size may only be temporary (e.g. we're compute XUL desired
|
|
// sizes).
|
|
PlaceScrollArea(state, oldScrollPosition);
|
|
if (!mHelper.mPostedReflowCallback) {
|
|
// Make sure we'll try scrolling to restored position
|
|
PresShell()->PostReflowCallback(&mHelper);
|
|
mHelper.mPostedReflowCallback = true;
|
|
}
|
|
|
|
bool didOnlyHScrollbar = mHelper.mOnlyNeedHScrollbarToScrollVVInsideLV;
|
|
bool didOnlyVScrollbar = mHelper.mOnlyNeedVScrollbarToScrollVVInsideLV;
|
|
mHelper.mOnlyNeedHScrollbarToScrollVVInsideLV =
|
|
state.mOnlyNeedHScrollbarToScrollVVInsideLV;
|
|
mHelper.mOnlyNeedVScrollbarToScrollVVInsideLV =
|
|
state.mOnlyNeedVScrollbarToScrollVVInsideLV;
|
|
|
|
bool didHaveHScrollbar = mHelper.mHasHorizontalScrollbar;
|
|
bool didHaveVScrollbar = mHelper.mHasVerticalScrollbar;
|
|
mHelper.mHasHorizontalScrollbar = state.mShowHScrollbar;
|
|
mHelper.mHasVerticalScrollbar = state.mShowVScrollbar;
|
|
nsRect newScrollAreaBounds = mHelper.mScrollPort;
|
|
nsRect newScrolledAreaBounds =
|
|
mHelper.mScrolledFrame->ScrollableOverflowRectRelativeToParent();
|
|
if (mHelper.mSkippedScrollbarLayout || reflowHScrollbar || reflowVScrollbar ||
|
|
reflowScrollCorner || HasAnyStateBits(NS_FRAME_IS_DIRTY) ||
|
|
didHaveHScrollbar != state.mShowHScrollbar ||
|
|
didHaveVScrollbar != state.mShowVScrollbar ||
|
|
didOnlyHScrollbar != mHelper.mOnlyNeedHScrollbarToScrollVVInsideLV ||
|
|
didOnlyVScrollbar != mHelper.mOnlyNeedVScrollbarToScrollVVInsideLV ||
|
|
!oldScrollAreaBounds.IsEqualEdges(newScrollAreaBounds) ||
|
|
!oldScrolledAreaBounds.IsEqualEdges(newScrolledAreaBounds)) {
|
|
if (!mHelper.mSuppressScrollbarUpdate) {
|
|
mHelper.mSkippedScrollbarLayout = false;
|
|
ScrollFrameHelper::SetScrollbarVisibility(mHelper.mHScrollbarBox,
|
|
state.mShowHScrollbar);
|
|
ScrollFrameHelper::SetScrollbarVisibility(mHelper.mVScrollbarBox,
|
|
state.mShowVScrollbar);
|
|
// place and reflow scrollbars
|
|
nsRect insideBorderArea =
|
|
nsRect(nsPoint(state.mComputedBorder.left, state.mComputedBorder.top),
|
|
layoutSize);
|
|
mHelper.LayoutScrollbars(state.mBoxState, insideBorderArea,
|
|
oldScrollAreaBounds);
|
|
} else {
|
|
mHelper.mSkippedScrollbarLayout = true;
|
|
}
|
|
}
|
|
if (mHelper.mIsRoot) {
|
|
if (RefPtr<MobileViewportManager> manager =
|
|
PresShell()->GetMobileViewportManager()) {
|
|
// Note that this runs during layout, and when we get here the root
|
|
// scrollframe has already been laid out. It may have added or removed
|
|
// scrollbars as a result of that layout, so we need to ensure the
|
|
// visual viewport is updated to account for that before we read the
|
|
// visual viewport size.
|
|
manager->UpdateVisualViewportSizeForPotentialScrollbarChange();
|
|
}
|
|
}
|
|
|
|
// Note that we need to do this after the
|
|
// UpdateVisualViewportSizeForPotentialScrollbarChange call above because that
|
|
// is what updates the visual viewport size and we need it to be up to date.
|
|
if (mHelper.mIsRoot && !mHelper.UsesOverlayScrollbars() &&
|
|
(didHaveHScrollbar != state.mShowHScrollbar ||
|
|
didHaveVScrollbar != state.mShowVScrollbar ||
|
|
didOnlyHScrollbar != mHelper.mOnlyNeedHScrollbarToScrollVVInsideLV ||
|
|
didOnlyVScrollbar != mHelper.mOnlyNeedVScrollbarToScrollVVInsideLV)) {
|
|
// Removing layout/classic scrollbars can make a previously valid vvoffset
|
|
// invalid. For example, if we are zoomed in on an overflow hidden document
|
|
// and then zoom back out, when apz reaches the initial resolution (ie 1.0)
|
|
// it won't know that we can remove the scrollbars, so the vvoffset can
|
|
// validly be upto the width/height of the scrollbars. After we reflow and
|
|
// remove the scrollbars the only valid vvoffset is (0,0). We could wait
|
|
// until we send the new frame metrics to apz and then have it reply with
|
|
// the new corrected vvoffset but having an inconsistent vvoffset causes
|
|
// problems so trigger the vvoffset to be re-set and re-clamped in
|
|
// ReflowFinished.
|
|
mHelper.mReclampVVOffsetInReflowFinished = true;
|
|
}
|
|
|
|
aDesiredSize.SetOverflowAreasToDesiredBounds();
|
|
|
|
mHelper.UpdateSticky();
|
|
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput,
|
|
aStatus);
|
|
|
|
if (!InInitialReflow() && !mHelper.mHadNonInitialReflow) {
|
|
mHelper.mHadNonInitialReflow = true;
|
|
}
|
|
|
|
if (mHelper.mIsRoot &&
|
|
!oldScrolledAreaBounds.IsEqualEdges(newScrolledAreaBounds)) {
|
|
mHelper.PostScrolledAreaEvent();
|
|
}
|
|
|
|
mHelper.UpdatePrevScrolledRect();
|
|
|
|
aStatus.Reset(); // This type of frame can't be split.
|
|
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
|
|
mHelper.PostOverflowEvent();
|
|
}
|
|
|
|
void nsHTMLScrollFrame::DidReflow(nsPresContext* aPresContext,
|
|
const ReflowInput* aReflowInput) {
|
|
nsContainerFrame::DidReflow(aPresContext, aReflowInput);
|
|
PresShell()->PostPendingScrollAnchorAdjustment(Anchor());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult nsHTMLScrollFrame::GetFrameName(nsAString& aResult) const {
|
|
return MakeFrameName(u"HTMLScroll"_ns, aResult);
|
|
}
|
|
#endif
|
|
|
|
#ifdef ACCESSIBILITY
|
|
a11y::AccType nsHTMLScrollFrame::AccessibleType() {
|
|
if (IsTableCaption()) {
|
|
return GetRect().IsEmpty() ? a11y::eNoType : a11y::eHTMLCaptionType;
|
|
}
|
|
|
|
// Create an accessible regardless of focusable state because the state can be
|
|
// changed during frame life cycle without any notifications to accessibility.
|
|
if (mContent->IsRootOfNativeAnonymousSubtree() ||
|
|
GetScrollStyles().IsHiddenInBothDirections()) {
|
|
return a11y::eNoType;
|
|
}
|
|
|
|
return a11y::eHyperTextType;
|
|
}
|
|
#endif
|
|
|
|
NS_QUERYFRAME_HEAD(nsHTMLScrollFrame)
|
|
NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
|
|
NS_QUERYFRAME_ENTRY(nsIScrollableFrame)
|
|
NS_QUERYFRAME_ENTRY(nsIStatefulFrame)
|
|
NS_QUERYFRAME_ENTRY(nsIScrollbarMediator)
|
|
NS_QUERYFRAME_ENTRY(nsHTMLScrollFrame)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
|
|
|
|
//----------nsXULScrollFrame-------------------------------------------
|
|
|
|
nsXULScrollFrame* NS_NewXULScrollFrame(PresShell* aPresShell,
|
|
ComputedStyle* aStyle, bool aIsRoot,
|
|
bool aClipAllDescendants) {
|
|
return new (aPresShell) nsXULScrollFrame(aStyle, aPresShell->GetPresContext(),
|
|
aIsRoot, aClipAllDescendants);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsXULScrollFrame)
|
|
|
|
nsXULScrollFrame::nsXULScrollFrame(ComputedStyle* aStyle,
|
|
nsPresContext* aPresContext, bool aIsRoot,
|
|
bool aClipAllDescendants)
|
|
: nsBoxFrame(aStyle, aPresContext, kClassID, aIsRoot),
|
|
mHelper(ALLOW_THIS_IN_INITIALIZER_LIST(this), aIsRoot) {
|
|
SetXULLayoutManager(nullptr);
|
|
mHelper.mClipAllDescendants = aClipAllDescendants;
|
|
}
|
|
|
|
void nsXULScrollFrame::ScrollbarActivityStarted() const {
|
|
if (mHelper.mScrollbarActivity) {
|
|
mHelper.mScrollbarActivity->ActivityStarted();
|
|
}
|
|
}
|
|
|
|
void nsXULScrollFrame::ScrollbarActivityStopped() const {
|
|
if (mHelper.mScrollbarActivity) {
|
|
mHelper.mScrollbarActivity->ActivityStopped();
|
|
}
|
|
}
|
|
|
|
nsMargin ScrollFrameHelper::GetDesiredScrollbarSizes(nsBoxLayoutState* aState) {
|
|
NS_ASSERTION(aState && aState->GetRenderingContext(),
|
|
"Must have rendering context in layout state for size "
|
|
"computations");
|
|
|
|
nsMargin result(0, 0, 0, 0);
|
|
|
|
if (mVScrollbarBox) {
|
|
nsSize size = mVScrollbarBox->GetXULPrefSize(*aState);
|
|
nsIFrame::AddXULMargin(mVScrollbarBox, size);
|
|
if (IsScrollbarOnRight())
|
|
result.left = size.width;
|
|
else
|
|
result.right = size.width;
|
|
}
|
|
|
|
if (mHScrollbarBox) {
|
|
nsSize size = mHScrollbarBox->GetXULPrefSize(*aState);
|
|
nsIFrame::AddXULMargin(mHScrollbarBox, size);
|
|
// We don't currently support any scripts that would require a scrollbar
|
|
// at the top. (Are there any?)
|
|
result.bottom = size.height;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
nscoord ScrollFrameHelper::GetNondisappearingScrollbarWidth(
|
|
nsBoxLayoutState* aState, WritingMode aWM) {
|
|
NS_ASSERTION(aState && aState->GetRenderingContext(),
|
|
"Must have rendering context in layout state for size "
|
|
"computations");
|
|
|
|
bool verticalWM = aWM.IsVertical();
|
|
// We need to have the proper un-themed scrollbar size, regardless of whether
|
|
// we're using e.g. scrollbar-width: thin, or overlay scrollbars. That's why
|
|
// we use ScrollbarNonDisappearing.
|
|
nsIFrame* box = verticalWM ? mHScrollbarBox : mVScrollbarBox;
|
|
if (box) {
|
|
auto sizes = aState->PresContext()->Theme()->GetScrollbarSizes(
|
|
aState->PresContext(), StyleScrollbarWidth::Auto,
|
|
nsITheme::Overlay::No);
|
|
return aState->PresContext()->DevPixelsToAppUnits(
|
|
verticalWM ? sizes.mHorizontal : sizes.mVertical);
|
|
}
|
|
|
|
nsMargin sizes(GetDesiredScrollbarSizes(aState));
|
|
return verticalWM ? sizes.TopBottom() : sizes.LeftRight();
|
|
}
|
|
|
|
void ScrollFrameHelper::HandleScrollbarStyleSwitching() {
|
|
// Check if we switched between scrollbar styles.
|
|
if (mScrollbarActivity &&
|
|
LookAndFeel::GetInt(LookAndFeel::IntID::UseOverlayScrollbars) == 0) {
|
|
mScrollbarActivity->Destroy();
|
|
mScrollbarActivity = nullptr;
|
|
} else if (!mScrollbarActivity &&
|
|
LookAndFeel::GetInt(LookAndFeel::IntID::UseOverlayScrollbars) !=
|
|
0) {
|
|
mScrollbarActivity = new ScrollbarActivity(do_QueryFrame(mOuter));
|
|
}
|
|
}
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
static bool IsFocused(nsIContent* aContent) {
|
|
// Some content elements, like the GetContent() of a scroll frame
|
|
// for a text input field, are inside anonymous subtrees, but the focus
|
|
// manager always reports a non-anonymous element as the focused one, so
|
|
// walk up the tree until we reach a non-anonymous element.
|
|
while (aContent && aContent->IsInNativeAnonymousSubtree()) {
|
|
aContent = aContent->GetParent();
|
|
}
|
|
|
|
return aContent ? nsContentUtils::IsFocusedContent(aContent) : false;
|
|
}
|
|
#endif
|
|
|
|
void ScrollFrameHelper::SetScrollableByAPZ(bool aScrollable) {
|
|
mScrollableByAPZ = aScrollable;
|
|
}
|
|
|
|
void ScrollFrameHelper::SetZoomableByAPZ(bool aZoomable) {
|
|
if (!nsLayoutUtils::UsesAsyncScrolling(mOuter)) {
|
|
// If APZ is disabled on this window, then we're never actually going to
|
|
// do any zooming. So we don't need to do any of the setup for it. Note
|
|
// that this function gets called from ZoomConstraintsClient even if APZ
|
|
// is disabled to indicate the zoomability of content.
|
|
aZoomable = false;
|
|
}
|
|
if (mZoomableByAPZ != aZoomable) {
|
|
// We might be changing the result of DecideScrollableLayer() so schedule a
|
|
// paint to make sure we pick up the result of that change.
|
|
mZoomableByAPZ = aZoomable;
|
|
mOuter->SchedulePaint();
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::SetHasOutOfFlowContentInsideFilter() {
|
|
mHasOutOfFlowContentInsideFilter = true;
|
|
}
|
|
|
|
bool ScrollFrameHelper::WantAsyncScroll() const {
|
|
ScrollStyles styles = GetScrollStylesFromFrame();
|
|
nscoord oneDevPixel =
|
|
GetScrolledFrame()->PresContext()->AppUnitsPerDevPixel();
|
|
nsRect scrollRange = GetLayoutScrollRange();
|
|
|
|
// If the page has a visual viewport size that's different from
|
|
// the layout viewport size at the current zoom level, we need to be
|
|
// able to scroll the visual viewport inside the layout viewport
|
|
// even if the page is not zoomable.
|
|
if (!GetVisualScrollRange().IsEqualInterior(scrollRange)) {
|
|
return true;
|
|
}
|
|
|
|
bool isVScrollable = (scrollRange.height >= oneDevPixel) &&
|
|
(styles.mVertical != StyleOverflow::Hidden);
|
|
bool isHScrollable = (scrollRange.width >= oneDevPixel) &&
|
|
(styles.mHorizontal != StyleOverflow::Hidden);
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
// Mobile platforms need focus to scroll text inputs.
|
|
bool canScrollWithoutScrollbars =
|
|
!IsForTextControlWithNoScrollbars() || IsFocused(mOuter->GetContent());
|
|
#else
|
|
bool canScrollWithoutScrollbars = true;
|
|
#endif
|
|
|
|
// The check for scroll bars was added in bug 825692 to prevent layerization
|
|
// of text inputs for performance reasons.
|
|
bool isVAsyncScrollable =
|
|
isVScrollable && (mVScrollbarBox || canScrollWithoutScrollbars);
|
|
bool isHAsyncScrollable =
|
|
isHScrollable && (mHScrollbarBox || canScrollWithoutScrollbars);
|
|
return isVAsyncScrollable || isHAsyncScrollable;
|
|
}
|
|
|
|
static nsRect GetOnePixelRangeAroundPoint(const nsPoint& aPoint,
|
|
bool aIsHorizontal) {
|
|
nsRect allowedRange(aPoint, nsSize());
|
|
nscoord halfPixel = nsPresContext::CSSPixelsToAppUnits(0.5f);
|
|
if (aIsHorizontal) {
|
|
allowedRange.x = aPoint.x - halfPixel;
|
|
allowedRange.width = halfPixel * 2 - 1;
|
|
} else {
|
|
allowedRange.y = aPoint.y - halfPixel;
|
|
allowedRange.height = halfPixel * 2 - 1;
|
|
}
|
|
return allowedRange;
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollByPage(
|
|
nsScrollbarFrame* aScrollbar, int32_t aDirection,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
ScrollByUnit(aScrollbar, ScrollMode::Smooth, aDirection, ScrollUnit::PAGES,
|
|
aSnap);
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollByWhole(
|
|
nsScrollbarFrame* aScrollbar, int32_t aDirection,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
ScrollByUnit(aScrollbar, ScrollMode::Instant, aDirection, ScrollUnit::WHOLE,
|
|
aSnap);
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollByLine(
|
|
nsScrollbarFrame* aScrollbar, int32_t aDirection,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
bool isHorizontal = aScrollbar->IsXULHorizontal();
|
|
nsIntPoint delta;
|
|
if (isHorizontal) {
|
|
const double kScrollMultiplier =
|
|
Preferences::GetInt("toolkit.scrollbox.horizontalScrollDistance",
|
|
NS_DEFAULT_HORIZONTAL_SCROLL_DISTANCE);
|
|
delta.x = aDirection * kScrollMultiplier;
|
|
if (GetLineScrollAmount().width * delta.x > GetPageScrollAmount().width) {
|
|
// The scroll frame is so small that the delta would be more
|
|
// than an entire page. Scroll by one page instead to maintain
|
|
// context.
|
|
ScrollByPage(aScrollbar, aDirection);
|
|
return;
|
|
}
|
|
} else {
|
|
const double kScrollMultiplier =
|
|
Preferences::GetInt("toolkit.scrollbox.verticalScrollDistance",
|
|
NS_DEFAULT_VERTICAL_SCROLL_DISTANCE);
|
|
delta.y = aDirection * kScrollMultiplier;
|
|
if (GetLineScrollAmount().height * delta.y > GetPageScrollAmount().height) {
|
|
// The scroll frame is so small that the delta would be more
|
|
// than an entire page. Scroll by one page instead to maintain
|
|
// context.
|
|
ScrollByPage(aScrollbar, aDirection);
|
|
return;
|
|
}
|
|
}
|
|
|
|
nsIntPoint overflow;
|
|
ScrollBy(delta, ScrollUnit::LINES, ScrollMode::Smooth, &overflow,
|
|
ScrollOrigin::Other, nsIScrollableFrame::NOT_MOMENTUM, aSnap);
|
|
}
|
|
|
|
void ScrollFrameHelper::RepeatButtonScroll(nsScrollbarFrame* aScrollbar) {
|
|
aScrollbar->MoveToNewPosition(nsScrollbarFrame::ImplementsScrollByUnit::Yes);
|
|
}
|
|
|
|
void ScrollFrameHelper::ThumbMoved(nsScrollbarFrame* aScrollbar,
|
|
nscoord aOldPos, nscoord aNewPos) {
|
|
MOZ_ASSERT(aScrollbar != nullptr);
|
|
bool isHorizontal = aScrollbar->IsXULHorizontal();
|
|
nsPoint current = GetScrollPosition();
|
|
nsPoint dest = current;
|
|
if (isHorizontal) {
|
|
dest.x = IsPhysicalLTR() ? aNewPos : aNewPos - GetLayoutScrollRange().width;
|
|
} else {
|
|
dest.y = aNewPos;
|
|
}
|
|
nsRect allowedRange = GetOnePixelRangeAroundPoint(dest, isHorizontal);
|
|
|
|
// Don't try to scroll if we're already at an acceptable place.
|
|
// Don't call Contains here since Contains returns false when the point is
|
|
// on the bottom or right edge of the rectangle.
|
|
if (allowedRange.ClampPoint(current) == current) {
|
|
return;
|
|
}
|
|
|
|
ScrollTo(dest, ScrollMode::Instant, ScrollOrigin::Other, &allowedRange);
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollbarReleased(nsScrollbarFrame* aScrollbar) {
|
|
// Scrollbar scrolling does not result in fling gestures, clear any
|
|
// accumulated velocity
|
|
mVelocityQueue.Reset();
|
|
|
|
// Perform scroll snapping, if needed. Scrollbar movement uses the same
|
|
// smooth scrolling animation as keyboard scrolling.
|
|
ScrollSnap(mDestination, ScrollMode::Smooth);
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollByUnit(
|
|
nsScrollbarFrame* aScrollbar, ScrollMode aMode, int32_t aDirection,
|
|
ScrollUnit aUnit, nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
MOZ_ASSERT(aScrollbar != nullptr);
|
|
bool isHorizontal = aScrollbar->IsXULHorizontal();
|
|
nsIntPoint delta;
|
|
if (isHorizontal) {
|
|
delta.x = aDirection;
|
|
} else {
|
|
delta.y = aDirection;
|
|
}
|
|
nsIntPoint overflow;
|
|
ScrollBy(delta, aUnit, aMode, &overflow, ScrollOrigin::Other,
|
|
nsIScrollableFrame::NOT_MOMENTUM, aSnap);
|
|
}
|
|
|
|
nsresult nsXULScrollFrame::CreateAnonymousContent(
|
|
nsTArray<ContentInfo>& aElements) {
|
|
return mHelper.CreateAnonymousContent(aElements);
|
|
}
|
|
|
|
void nsXULScrollFrame::AppendAnonymousContentTo(
|
|
nsTArray<nsIContent*>& aElements, uint32_t aFilter) {
|
|
mHelper.AppendAnonymousContentTo(aElements, aFilter);
|
|
}
|
|
|
|
void nsXULScrollFrame::DestroyFrom(nsIFrame* aDestructRoot,
|
|
PostDestroyData& aPostDestroyData) {
|
|
mHelper.Destroy(aPostDestroyData);
|
|
nsBoxFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
|
|
}
|
|
|
|
void nsXULScrollFrame::SetInitialChildList(ChildListID aListID,
|
|
nsFrameList& aChildList) {
|
|
nsBoxFrame::SetInitialChildList(aListID, aChildList);
|
|
if (aListID == kPrincipalList) {
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
}
|
|
|
|
void nsXULScrollFrame::AppendFrames(ChildListID aListID,
|
|
nsFrameList& aFrameList) {
|
|
nsBoxFrame::AppendFrames(aListID, aFrameList);
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
|
|
void nsXULScrollFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
|
|
const nsLineList::iterator* aPrevFrameLine,
|
|
nsFrameList& aFrameList) {
|
|
nsBoxFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine, aFrameList);
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
|
|
void nsXULScrollFrame::RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) {
|
|
nsBoxFrame::RemoveFrame(aListID, aOldFrame);
|
|
mHelper.ReloadChildFrames();
|
|
}
|
|
|
|
nsresult nsXULScrollFrame::GetXULPadding(nsMargin& aMargin) {
|
|
aMargin.SizeTo(0, 0, 0, 0);
|
|
return NS_OK;
|
|
}
|
|
|
|
nscoord nsXULScrollFrame::GetXULBoxAscent(nsBoxLayoutState& aState) {
|
|
if (!mHelper.mScrolledFrame) return 0;
|
|
|
|
nscoord ascent = mHelper.mScrolledFrame->GetXULBoxAscent(aState);
|
|
nsMargin m(0, 0, 0, 0);
|
|
GetXULBorderAndPadding(m);
|
|
ascent += m.top;
|
|
GetXULMargin(m);
|
|
ascent += m.top;
|
|
|
|
return ascent;
|
|
}
|
|
|
|
nsSize nsXULScrollFrame::GetXULPrefSize(nsBoxLayoutState& aState) {
|
|
nsSize pref = mHelper.mScrolledFrame->GetXULPrefSize(aState);
|
|
|
|
ScrollStyles styles = GetScrollStyles();
|
|
|
|
// scrolled frames don't have their own margins
|
|
|
|
if (mHelper.mVScrollbarBox && styles.mVertical == StyleOverflow::Scroll) {
|
|
nsSize vSize = mHelper.mVScrollbarBox->GetXULPrefSize(aState);
|
|
nsIFrame::AddXULMargin(mHelper.mVScrollbarBox, vSize);
|
|
pref.width += vSize.width;
|
|
}
|
|
|
|
if (mHelper.mHScrollbarBox && styles.mHorizontal == StyleOverflow::Scroll) {
|
|
nsSize hSize = mHelper.mHScrollbarBox->GetXULPrefSize(aState);
|
|
nsIFrame::AddXULMargin(mHelper.mHScrollbarBox, hSize);
|
|
pref.height += hSize.height;
|
|
}
|
|
|
|
AddXULBorderAndPadding(pref);
|
|
bool widthSet, heightSet;
|
|
nsIFrame::AddXULPrefSize(this, pref, widthSet, heightSet);
|
|
return pref;
|
|
}
|
|
|
|
nsSize nsXULScrollFrame::GetXULMinSize(nsBoxLayoutState& aState) {
|
|
nsSize min = mHelper.mScrolledFrame->GetXULMinSizeForScrollArea(aState);
|
|
|
|
ScrollStyles styles = GetScrollStyles();
|
|
|
|
if (mHelper.mVScrollbarBox && styles.mVertical == StyleOverflow::Scroll) {
|
|
nsSize vSize = mHelper.mVScrollbarBox->GetXULMinSize(aState);
|
|
AddXULMargin(mHelper.mVScrollbarBox, vSize);
|
|
min.width += vSize.width;
|
|
if (min.height < vSize.height) min.height = vSize.height;
|
|
}
|
|
|
|
if (mHelper.mHScrollbarBox && styles.mHorizontal == StyleOverflow::Scroll) {
|
|
nsSize hSize = mHelper.mHScrollbarBox->GetXULMinSize(aState);
|
|
AddXULMargin(mHelper.mHScrollbarBox, hSize);
|
|
min.height += hSize.height;
|
|
if (min.width < hSize.width) min.width = hSize.width;
|
|
}
|
|
|
|
AddXULBorderAndPadding(min);
|
|
bool widthSet, heightSet;
|
|
nsIFrame::AddXULMinSize(this, min, widthSet, heightSet);
|
|
return min;
|
|
}
|
|
|
|
nsSize nsXULScrollFrame::GetXULMaxSize(nsBoxLayoutState& aState) {
|
|
nsSize maxSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
|
|
|
|
AddXULBorderAndPadding(maxSize);
|
|
bool widthSet, heightSet;
|
|
nsIFrame::AddXULMaxSize(this, maxSize, widthSet, heightSet);
|
|
return maxSize;
|
|
}
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult nsXULScrollFrame::GetFrameName(nsAString& aResult) const {
|
|
return MakeFrameName(u"XULScroll"_ns, aResult);
|
|
}
|
|
#endif
|
|
|
|
NS_IMETHODIMP
|
|
nsXULScrollFrame::DoXULLayout(nsBoxLayoutState& aState) {
|
|
ReflowChildFlags flags = aState.LayoutFlags();
|
|
nsresult rv = XULLayout(aState);
|
|
aState.SetLayoutFlags(flags);
|
|
return rv;
|
|
}
|
|
|
|
NS_QUERYFRAME_HEAD(nsXULScrollFrame)
|
|
NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
|
|
NS_QUERYFRAME_ENTRY(nsIScrollableFrame)
|
|
NS_QUERYFRAME_ENTRY(nsIStatefulFrame)
|
|
NS_QUERYFRAME_ENTRY(nsIScrollbarMediator)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
|
|
|
|
//-------------------- Helper ----------------------
|
|
|
|
// AsyncSmoothMSDScroll has ref counting.
|
|
class ScrollFrameHelper::AsyncSmoothMSDScroll final
|
|
: public nsARefreshObserver {
|
|
public:
|
|
AsyncSmoothMSDScroll(const nsPoint& aInitialPosition,
|
|
const nsPoint& aInitialDestination,
|
|
const nsSize& aInitialVelocity, const nsRect& aRange,
|
|
const mozilla::TimeStamp& aStartTime,
|
|
nsPresContext* aPresContext)
|
|
: mXAxisModel(aInitialPosition.x, aInitialDestination.x,
|
|
aInitialVelocity.width,
|
|
StaticPrefs::layout_css_scroll_behavior_spring_constant(),
|
|
StaticPrefs::layout_css_scroll_behavior_damping_ratio()),
|
|
mYAxisModel(aInitialPosition.y, aInitialDestination.y,
|
|
aInitialVelocity.height,
|
|
StaticPrefs::layout_css_scroll_behavior_spring_constant(),
|
|
StaticPrefs::layout_css_scroll_behavior_damping_ratio()),
|
|
mRange(aRange),
|
|
mLastRefreshTime(aStartTime),
|
|
mCallee(nullptr),
|
|
mOneDevicePixelInAppUnits(aPresContext->DevPixelsToAppUnits(1)) {
|
|
Telemetry::SetHistogramRecordingEnabled(
|
|
Telemetry::FX_REFRESH_DRIVER_SYNC_SCROLL_FRAME_DELAY_MS, true);
|
|
}
|
|
|
|
NS_INLINE_DECL_REFCOUNTING(AsyncSmoothMSDScroll, override)
|
|
|
|
nsSize GetVelocity() {
|
|
// In nscoords per second
|
|
return nsSize(mXAxisModel.GetVelocity(), mYAxisModel.GetVelocity());
|
|
}
|
|
|
|
nsPoint GetPosition() {
|
|
// In nscoords
|
|
return nsPoint(NSToCoordRound(mXAxisModel.GetPosition()),
|
|
NSToCoordRound(mYAxisModel.GetPosition()));
|
|
}
|
|
|
|
void SetDestination(const nsPoint& aDestination) {
|
|
mXAxisModel.SetDestination(static_cast<int32_t>(aDestination.x));
|
|
mYAxisModel.SetDestination(static_cast<int32_t>(aDestination.y));
|
|
}
|
|
|
|
void SetRange(const nsRect& aRange) { mRange = aRange; }
|
|
|
|
nsRect GetRange() { return mRange; }
|
|
|
|
void Simulate(const TimeDuration& aDeltaTime) {
|
|
mXAxisModel.Simulate(aDeltaTime);
|
|
mYAxisModel.Simulate(aDeltaTime);
|
|
|
|
nsPoint desired = GetPosition();
|
|
nsPoint clamped = mRange.ClampPoint(desired);
|
|
if (desired.x != clamped.x) {
|
|
// The scroll has hit the "wall" at the left or right edge of the allowed
|
|
// scroll range.
|
|
// Absorb the impact to avoid bounceback effect.
|
|
mXAxisModel.SetVelocity(0.0);
|
|
mXAxisModel.SetPosition(clamped.x);
|
|
}
|
|
|
|
if (desired.y != clamped.y) {
|
|
// The scroll has hit the "wall" at the left or right edge of the allowed
|
|
// scroll range.
|
|
// Absorb the impact to avoid bounceback effect.
|
|
mYAxisModel.SetVelocity(0.0);
|
|
mYAxisModel.SetPosition(clamped.y);
|
|
}
|
|
}
|
|
|
|
bool IsFinished() {
|
|
return mXAxisModel.IsFinished(mOneDevicePixelInAppUnits) &&
|
|
mYAxisModel.IsFinished(mOneDevicePixelInAppUnits);
|
|
}
|
|
|
|
virtual void WillRefresh(mozilla::TimeStamp aTime) override {
|
|
mozilla::TimeDuration deltaTime = aTime - mLastRefreshTime;
|
|
mLastRefreshTime = aTime;
|
|
|
|
// The callback may release "this".
|
|
// We don't access members after returning, so no need for KungFuDeathGrip.
|
|
ScrollFrameHelper::AsyncSmoothMSDScrollCallback(mCallee, deltaTime);
|
|
}
|
|
|
|
/*
|
|
* Set a refresh observer for smooth scroll iterations (and start observing).
|
|
* Should be used at most once during the lifetime of this object.
|
|
*/
|
|
void SetRefreshObserver(ScrollFrameHelper* aCallee) {
|
|
NS_ASSERTION(aCallee && !mCallee,
|
|
"AsyncSmoothMSDScroll::SetRefreshObserver - Invalid usage.");
|
|
|
|
RefreshDriver(aCallee)->AddRefreshObserver(this, FlushType::Style,
|
|
"Smooth scroll (MSD) animation");
|
|
mCallee = aCallee;
|
|
}
|
|
|
|
/**
|
|
* The mCallee holds a strong ref to us since the refresh driver doesn't.
|
|
* Our dtor and mCallee's Destroy() method both call RemoveObserver() -
|
|
* whichever comes first removes us from the refresh driver.
|
|
*/
|
|
void RemoveObserver() {
|
|
if (mCallee) {
|
|
RefreshDriver(mCallee)->RemoveRefreshObserver(this, FlushType::Style);
|
|
mCallee = nullptr;
|
|
}
|
|
}
|
|
|
|
private:
|
|
// Private destructor, to discourage deletion outside of Release():
|
|
~AsyncSmoothMSDScroll() {
|
|
RemoveObserver();
|
|
Telemetry::SetHistogramRecordingEnabled(
|
|
Telemetry::FX_REFRESH_DRIVER_SYNC_SCROLL_FRAME_DELAY_MS, false);
|
|
}
|
|
|
|
nsRefreshDriver* RefreshDriver(ScrollFrameHelper* aCallee) {
|
|
return aCallee->mOuter->PresContext()->RefreshDriver();
|
|
}
|
|
|
|
mozilla::layers::AxisPhysicsMSDModel mXAxisModel, mYAxisModel;
|
|
nsRect mRange;
|
|
mozilla::TimeStamp mLastRefreshTime;
|
|
ScrollFrameHelper* mCallee;
|
|
nscoord mOneDevicePixelInAppUnits;
|
|
};
|
|
|
|
// AsyncScroll has ref counting.
|
|
class ScrollFrameHelper::AsyncScroll final : public nsARefreshObserver {
|
|
public:
|
|
typedef mozilla::TimeStamp TimeStamp;
|
|
typedef mozilla::TimeDuration TimeDuration;
|
|
|
|
explicit AsyncScroll()
|
|
: mOrigin(ScrollOrigin::NotSpecified), mCallee(nullptr) {
|
|
Telemetry::SetHistogramRecordingEnabled(
|
|
Telemetry::FX_REFRESH_DRIVER_SYNC_SCROLL_FRAME_DELAY_MS, true);
|
|
}
|
|
|
|
private:
|
|
// Private destructor, to discourage deletion outside of Release():
|
|
~AsyncScroll() {
|
|
RemoveObserver();
|
|
Telemetry::SetHistogramRecordingEnabled(
|
|
Telemetry::FX_REFRESH_DRIVER_SYNC_SCROLL_FRAME_DELAY_MS, false);
|
|
}
|
|
|
|
public:
|
|
void InitSmoothScroll(TimeStamp aTime, nsPoint aInitialPosition,
|
|
nsPoint aDestination, ScrollOrigin aOrigin,
|
|
const nsRect& aRange, const nsSize& aCurrentVelocity);
|
|
void Init(const nsRect& aRange) {
|
|
mAnimationPhysics = nullptr;
|
|
mRange = aRange;
|
|
}
|
|
|
|
bool IsSmoothScroll() { return mAnimationPhysics != nullptr; }
|
|
|
|
bool IsFinished(const TimeStamp& aTime) const {
|
|
MOZ_RELEASE_ASSERT(mAnimationPhysics);
|
|
return mAnimationPhysics->IsFinished(aTime);
|
|
}
|
|
|
|
nsPoint PositionAt(const TimeStamp& aTime) const {
|
|
MOZ_RELEASE_ASSERT(mAnimationPhysics);
|
|
return mAnimationPhysics->PositionAt(aTime);
|
|
}
|
|
|
|
nsSize VelocityAt(const TimeStamp& aTime) const {
|
|
MOZ_RELEASE_ASSERT(mAnimationPhysics);
|
|
return mAnimationPhysics->VelocityAt(aTime);
|
|
}
|
|
|
|
// Most recent scroll origin.
|
|
ScrollOrigin mOrigin;
|
|
|
|
// Allowed destination positions around mDestination
|
|
nsRect mRange;
|
|
|
|
private:
|
|
void InitPreferences(TimeStamp aTime, nsAtom* aOrigin);
|
|
|
|
UniquePtr<ScrollAnimationPhysics> mAnimationPhysics;
|
|
|
|
// The next section is observer/callback management
|
|
// Bodies of WillRefresh and RefreshDriver contain ScrollFrameHelper specific
|
|
// code.
|
|
public:
|
|
NS_INLINE_DECL_REFCOUNTING(AsyncScroll, override)
|
|
|
|
/*
|
|
* Set a refresh observer for smooth scroll iterations (and start observing).
|
|
* Should be used at most once during the lifetime of this object.
|
|
*/
|
|
void SetRefreshObserver(ScrollFrameHelper* aCallee) {
|
|
NS_ASSERTION(aCallee && !mCallee,
|
|
"AsyncScroll::SetRefreshObserver - Invalid usage.");
|
|
|
|
RefreshDriver(aCallee)->AddRefreshObserver(this, FlushType::Style,
|
|
"Smooth scroll animation");
|
|
mCallee = aCallee;
|
|
PresShell* presShell = mCallee->mOuter->PresShell();
|
|
MOZ_ASSERT(presShell);
|
|
presShell->SuppressDisplayport(true);
|
|
}
|
|
|
|
virtual void WillRefresh(mozilla::TimeStamp aTime) override {
|
|
// The callback may release "this".
|
|
// We don't access members after returning, so no need for KungFuDeathGrip.
|
|
ScrollFrameHelper::AsyncScrollCallback(mCallee, aTime);
|
|
}
|
|
|
|
/**
|
|
* The mCallee holds a strong ref to us since the refresh driver doesn't.
|
|
* Our dtor and mCallee's Destroy() method both call RemoveObserver() -
|
|
* whichever comes first removes us from the refresh driver.
|
|
*/
|
|
void RemoveObserver() {
|
|
if (mCallee) {
|
|
RefreshDriver(mCallee)->RemoveRefreshObserver(this, FlushType::Style);
|
|
PresShell* presShell = mCallee->mOuter->PresShell();
|
|
MOZ_ASSERT(presShell);
|
|
presShell->SuppressDisplayport(false);
|
|
mCallee = nullptr;
|
|
}
|
|
}
|
|
|
|
private:
|
|
ScrollFrameHelper* mCallee;
|
|
|
|
nsRefreshDriver* RefreshDriver(ScrollFrameHelper* aCallee) {
|
|
return aCallee->mOuter->PresContext()->RefreshDriver();
|
|
}
|
|
};
|
|
|
|
void ScrollFrameHelper::AsyncScroll::InitSmoothScroll(
|
|
TimeStamp aTime, nsPoint aInitialPosition, nsPoint aDestination,
|
|
ScrollOrigin aOrigin, const nsRect& aRange,
|
|
const nsSize& aCurrentVelocity) {
|
|
switch (aOrigin) {
|
|
case ScrollOrigin::NotSpecified:
|
|
case ScrollOrigin::Restore:
|
|
case ScrollOrigin::Relative:
|
|
// We don't have special prefs for "restore", just treat it as "other".
|
|
// "restore" scrolls are (for now) always instant anyway so unless
|
|
// something changes we should never have aOrigin ==
|
|
// ScrollOrigin::Restore here.
|
|
aOrigin = ScrollOrigin::Other;
|
|
break;
|
|
case ScrollOrigin::Apz:
|
|
// Likewise we should never get APZ-triggered scrolls here, and if that
|
|
// changes something is likely broken somewhere.
|
|
MOZ_ASSERT(false);
|
|
break;
|
|
default:
|
|
break;
|
|
};
|
|
|
|
// Read preferences only on first iteration or for a different event origin.
|
|
if (!mAnimationPhysics || aOrigin != mOrigin) {
|
|
mOrigin = aOrigin;
|
|
if (StaticPrefs::general_smoothScroll_msdPhysics_enabled()) {
|
|
mAnimationPhysics =
|
|
MakeUnique<ScrollAnimationMSDPhysics>(aInitialPosition);
|
|
} else {
|
|
ScrollAnimationBezierPhysicsSettings settings =
|
|
layers::apz::ComputeBezierAnimationSettingsForOrigin(mOrigin);
|
|
mAnimationPhysics =
|
|
MakeUnique<ScrollAnimationBezierPhysics>(aInitialPosition, settings);
|
|
}
|
|
}
|
|
|
|
mRange = aRange;
|
|
|
|
mAnimationPhysics->Update(aTime, aDestination, aCurrentVelocity);
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsSmoothScrollingEnabled() {
|
|
return StaticPrefs::general_smoothScroll();
|
|
}
|
|
|
|
class ScrollFrameActivityTracker final
|
|
: public nsExpirationTracker<ScrollFrameHelper, 4> {
|
|
public:
|
|
// Wait for 3-4s between scrolls before we remove our layers.
|
|
// That's 4 generations of 1s each.
|
|
enum { TIMEOUT_MS = 1000 };
|
|
explicit ScrollFrameActivityTracker(nsIEventTarget* aEventTarget)
|
|
: nsExpirationTracker<ScrollFrameHelper, 4>(
|
|
TIMEOUT_MS, "ScrollFrameActivityTracker", aEventTarget) {}
|
|
~ScrollFrameActivityTracker() { AgeAllGenerations(); }
|
|
|
|
virtual void NotifyExpired(ScrollFrameHelper* aObject) override {
|
|
RemoveObject(aObject);
|
|
aObject->MarkNotRecentlyScrolled();
|
|
}
|
|
};
|
|
|
|
static ScrollFrameActivityTracker* gScrollFrameActivityTracker = nullptr;
|
|
|
|
ScrollFrameHelper::ScrollFrameHelper(nsContainerFrame* aOuter, bool aIsRoot)
|
|
: mHScrollbarBox(nullptr),
|
|
mVScrollbarBox(nullptr),
|
|
mScrolledFrame(nullptr),
|
|
mScrollCornerBox(nullptr),
|
|
mResizerBox(nullptr),
|
|
mOuter(aOuter),
|
|
mReferenceFrameDuringPainting(nullptr),
|
|
mAsyncScroll(nullptr),
|
|
mAsyncSmoothMSDScroll(nullptr),
|
|
mLastScrollOrigin(ScrollOrigin::None),
|
|
mDestination(0, 0),
|
|
mRestorePos(-1, -1),
|
|
mLastPos(-1, -1),
|
|
mApzScrollPos(0, 0),
|
|
mScrollPosForLayerPixelAlignment(-1, -1),
|
|
mLastUpdateFramesPos(-1, -1),
|
|
mDisplayPortAtLastFrameUpdate(),
|
|
mScrollParentID(mozilla::layers::ScrollableLayerGuid::NULL_SCROLL_ID),
|
|
mAnchor(this),
|
|
mAllowScrollOriginDowngrade(false),
|
|
mHadDisplayPortAtLastFrameUpdate(false),
|
|
mNeverHasVerticalScrollbar(false),
|
|
mNeverHasHorizontalScrollbar(false),
|
|
mHasVerticalScrollbar(false),
|
|
mHasHorizontalScrollbar(false),
|
|
mOnlyNeedVScrollbarToScrollVVInsideLV(false),
|
|
mOnlyNeedHScrollbarToScrollVVInsideLV(false),
|
|
mFrameIsUpdatingScrollbar(false),
|
|
mDidHistoryRestore(false),
|
|
mIsRoot(aIsRoot),
|
|
mClipAllDescendants(aIsRoot),
|
|
mSuppressScrollbarUpdate(false),
|
|
mSkippedScrollbarLayout(false),
|
|
mHadNonInitialReflow(false),
|
|
mFirstReflow(true),
|
|
mHorizontalOverflow(false),
|
|
mVerticalOverflow(false),
|
|
mPostedReflowCallback(false),
|
|
mMayHaveDirtyFixedChildren(false),
|
|
mUpdateScrollbarAttributes(false),
|
|
mHasBeenScrolledRecently(false),
|
|
mWillBuildScrollableLayer(false),
|
|
mIsParentToActiveScrollFrames(false),
|
|
mAddClipRectToLayer(false),
|
|
mHasBeenScrolled(false),
|
|
mIgnoreMomentumScroll(false),
|
|
mTransformingByAPZ(false),
|
|
mScrollableByAPZ(false),
|
|
mZoomableByAPZ(false),
|
|
mHasOutOfFlowContentInsideFilter(false),
|
|
mSuppressScrollbarRepaints(false),
|
|
mIsUsingMinimumScaleSize(false),
|
|
mMinimumScaleSizeChanged(false),
|
|
mProcessingScrollEvent(false),
|
|
mApzAnimationInProgress(false),
|
|
mApzAnimationRequested(false),
|
|
mReclampVVOffsetInReflowFinished(false),
|
|
mVelocityQueue(aOuter->PresContext()) {
|
|
AppendScrollUpdate(ScrollPositionUpdate::NewScrollframe(nsPoint()));
|
|
|
|
if (LookAndFeel::GetInt(LookAndFeel::IntID::UseOverlayScrollbars) != 0) {
|
|
mScrollbarActivity = new ScrollbarActivity(do_QueryFrame(aOuter));
|
|
}
|
|
|
|
if (IsAlwaysActive() && StaticPrefs::layers_enable_tiles_AtStartup() &&
|
|
!nsLayoutUtils::UsesAsyncScrolling(mOuter) && mOuter->GetContent()) {
|
|
// If we have tiling but no APZ, then set a 0-margin display port on
|
|
// active scroll containers so that we paint by whole tile increments
|
|
// when scrolling.
|
|
DisplayPortUtils::SetDisplayPortMargins(
|
|
mOuter->GetContent(), mOuter->PresShell(),
|
|
DisplayPortMargins::Empty(mOuter->GetContent()),
|
|
DisplayPortUtils::ClearMinimalDisplayPortProperty::Yes, 0);
|
|
DisplayPortUtils::SetZeroMarginDisplayPortOnAsyncScrollableAncestors(
|
|
mOuter);
|
|
}
|
|
|
|
if (mIsRoot) {
|
|
mZoomableByAPZ = mOuter->PresShell()->GetZoomableByAPZ();
|
|
}
|
|
}
|
|
|
|
ScrollFrameHelper::~ScrollFrameHelper() {
|
|
if (mScrollEvent) {
|
|
mScrollEvent->Revoke();
|
|
}
|
|
if (mScrollEndEvent) {
|
|
mScrollEndEvent->Revoke();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Callback function from AsyncSmoothMSDScroll, used in
|
|
* ScrollFrameHelper::ScrollTo
|
|
*/
|
|
void ScrollFrameHelper::AsyncSmoothMSDScrollCallback(
|
|
ScrollFrameHelper* aInstance, mozilla::TimeDuration aDeltaTime) {
|
|
NS_ASSERTION(aInstance != nullptr, "aInstance must not be null");
|
|
NS_ASSERTION(aInstance->mAsyncSmoothMSDScroll,
|
|
"Did not expect AsyncSmoothMSDScrollCallback without an active "
|
|
"MSD scroll.");
|
|
|
|
nsRect range = aInstance->mAsyncSmoothMSDScroll->GetRange();
|
|
aInstance->mAsyncSmoothMSDScroll->Simulate(aDeltaTime);
|
|
|
|
if (!aInstance->mAsyncSmoothMSDScroll->IsFinished()) {
|
|
nsPoint destination = aInstance->mAsyncSmoothMSDScroll->GetPosition();
|
|
// Allow this scroll operation to land on any pixel boundary within the
|
|
// allowed scroll range for this frame.
|
|
// If the MSD is under-dampened or the destination is changed rapidly,
|
|
// it is expected (and desired) that the scrolling may overshoot.
|
|
nsRect intermediateRange = nsRect(destination, nsSize()).UnionEdges(range);
|
|
aInstance->ScrollToImpl(destination, intermediateRange);
|
|
// 'aInstance' might be destroyed here
|
|
return;
|
|
}
|
|
|
|
aInstance->CompleteAsyncScroll(range);
|
|
}
|
|
|
|
/*
|
|
* Callback function from AsyncScroll, used in ScrollFrameHelper::ScrollTo
|
|
*/
|
|
void ScrollFrameHelper::AsyncScrollCallback(ScrollFrameHelper* aInstance,
|
|
mozilla::TimeStamp aTime) {
|
|
MOZ_ASSERT(aInstance != nullptr, "aInstance must not be null");
|
|
MOZ_ASSERT(
|
|
aInstance->mAsyncScroll,
|
|
"Did not expect AsyncScrollCallback without an active async scroll.");
|
|
|
|
if (!aInstance || !aInstance->mAsyncScroll) {
|
|
return; // XXX wallpaper bug 1107353 for now.
|
|
}
|
|
|
|
nsRect range = aInstance->mAsyncScroll->mRange;
|
|
if (aInstance->mAsyncScroll->IsSmoothScroll()) {
|
|
if (!aInstance->mAsyncScroll->IsFinished(aTime)) {
|
|
nsPoint destination = aInstance->mAsyncScroll->PositionAt(aTime);
|
|
// Allow this scroll operation to land on any pixel boundary between the
|
|
// current position and the final allowed range. (We don't want
|
|
// intermediate steps to be more constrained than the final step!)
|
|
nsRect intermediateRange =
|
|
nsRect(aInstance->GetScrollPosition(), nsSize()).UnionEdges(range);
|
|
aInstance->ScrollToImpl(destination, intermediateRange);
|
|
// 'aInstance' might be destroyed here
|
|
return;
|
|
}
|
|
}
|
|
|
|
aInstance->CompleteAsyncScroll(range);
|
|
}
|
|
|
|
void ScrollFrameHelper::CompleteAsyncScroll(const nsRect& aRange,
|
|
ScrollOrigin aOrigin) {
|
|
// Apply desired destination range since this is the last step of scrolling.
|
|
RemoveObservers();
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
ScrollToImpl(mDestination, aRange, aOrigin);
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
// We are done scrolling, set our destination to wherever we actually ended
|
|
// up scrolling to.
|
|
mDestination = GetScrollPosition();
|
|
PostScrollEndEvent();
|
|
}
|
|
|
|
bool ScrollFrameHelper::HasBgAttachmentLocal() const {
|
|
const nsStyleBackground* bg = mOuter->StyleBackground();
|
|
return bg->HasLocalBackground();
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollTo(nsPoint aScrollPosition, ScrollMode aMode,
|
|
ScrollOrigin aOrigin, const nsRect* aRange,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
if (aOrigin == ScrollOrigin::NotSpecified) {
|
|
aOrigin = ScrollOrigin::Other;
|
|
}
|
|
ScrollToWithOrigin(aScrollPosition, aMode, aOrigin, aRange, aSnap);
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollToCSSPixels(
|
|
const CSSIntPoint& aScrollPosition, ScrollMode aMode,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap, ScrollOrigin aOrigin) {
|
|
nsPoint current = GetScrollPosition();
|
|
CSSIntPoint currentCSSPixels = GetScrollPositionCSSPixels();
|
|
nsPoint pt = CSSPoint::ToAppUnits(aScrollPosition);
|
|
if (aSnap == nsIScrollableFrame::DEFAULT) {
|
|
aSnap = nsIScrollableFrame::ENABLE_SNAP;
|
|
}
|
|
|
|
if (aOrigin == ScrollOrigin::NotSpecified) {
|
|
aOrigin = ScrollOrigin::Other;
|
|
}
|
|
|
|
nscoord halfPixel = nsPresContext::CSSPixelsToAppUnits(0.5f);
|
|
nsRect range(pt.x - halfPixel, pt.y - halfPixel, 2 * halfPixel - 1,
|
|
2 * halfPixel - 1);
|
|
// XXX I don't think the following blocks are needed anymore, now that
|
|
// ScrollToImpl simply tries to scroll an integer number of layer
|
|
// pixels from the current position
|
|
if (currentCSSPixels.x == aScrollPosition.x) {
|
|
pt.x = current.x;
|
|
range.x = pt.x;
|
|
range.width = 0;
|
|
}
|
|
if (currentCSSPixels.y == aScrollPosition.y) {
|
|
pt.y = current.y;
|
|
range.y = pt.y;
|
|
range.height = 0;
|
|
}
|
|
ScrollTo(pt, aMode, aOrigin, &range, aSnap);
|
|
// 'this' might be destroyed here
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollToCSSPixelsApproximate(
|
|
const CSSPoint& aScrollPosition, ScrollOrigin aOrigin) {
|
|
nsPoint pt = CSSPoint::ToAppUnits(aScrollPosition);
|
|
nscoord halfRange = nsPresContext::CSSPixelsToAppUnits(1000);
|
|
nsRect range(pt.x - halfRange, pt.y - halfRange, 2 * halfRange - 1,
|
|
2 * halfRange - 1);
|
|
ScrollToWithOrigin(pt, ScrollMode::Instant, aOrigin, &range);
|
|
// 'this' might be destroyed here
|
|
}
|
|
|
|
CSSIntPoint ScrollFrameHelper::GetScrollPositionCSSPixels() {
|
|
return CSSIntPoint::FromAppUnitsRounded(GetScrollPosition());
|
|
}
|
|
|
|
/*
|
|
* this method wraps calls to ScrollToImpl(), either in one shot or
|
|
* incrementally, based on the setting of the smoothness scroll pref
|
|
*/
|
|
void ScrollFrameHelper::ScrollToWithOrigin(
|
|
nsPoint aScrollPosition, ScrollMode aMode, ScrollOrigin aOrigin,
|
|
const nsRect* aRange, nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
// None is never a valid scroll origin to be passed in.
|
|
MOZ_ASSERT(aOrigin != ScrollOrigin::None);
|
|
|
|
if (aOrigin != ScrollOrigin::Restore) {
|
|
// If we're doing a non-restore scroll, we don't want to later
|
|
// override it by restoring our saved scroll position.
|
|
SCROLLRESTORE_LOG("%p: Clearing mRestorePos (cur=%s, dst=%s)\n", this,
|
|
ToString(GetScrollPosition()).c_str(),
|
|
ToString(aScrollPosition).c_str());
|
|
mRestorePos.x = mRestorePos.y = -1;
|
|
}
|
|
|
|
bool willSnap = false;
|
|
if (aSnap == nsIScrollableFrame::ENABLE_SNAP) {
|
|
willSnap = GetSnapPointForDestination(ScrollUnit::DEVICE_PIXELS,
|
|
mDestination, aScrollPosition);
|
|
}
|
|
|
|
nsRect scrollRange = GetLayoutScrollRange();
|
|
mDestination = scrollRange.ClampPoint(aScrollPosition);
|
|
if (mDestination != aScrollPosition && aOrigin == ScrollOrigin::Restore &&
|
|
GetPageLoadingState() != LoadingState::Loading) {
|
|
// If we're doing a restore but the scroll position is clamped, promote
|
|
// the origin from one that APZ can clobber to one that it can't clobber.
|
|
aOrigin = ScrollOrigin::Other;
|
|
}
|
|
|
|
nsRect range =
|
|
aRange && !willSnap ? *aRange : nsRect(aScrollPosition, nsSize(0, 0));
|
|
|
|
if (aMode == ScrollMode::Instant) {
|
|
// Asynchronous scrolling is not allowed, so we'll kill any existing
|
|
// async-scrolling process and do an instant scroll.
|
|
CompleteAsyncScroll(range, aOrigin);
|
|
mApzSmoothScrollDestination = Nothing();
|
|
return;
|
|
}
|
|
|
|
if (aMode != ScrollMode::SmoothMsd) {
|
|
// If we get a non-smooth-scroll, reset the cached APZ scroll destination,
|
|
// so that we know to process the next smooth-scroll destined for APZ.
|
|
mApzSmoothScrollDestination = Nothing();
|
|
}
|
|
|
|
nsPresContext* presContext = mOuter->PresContext();
|
|
TimeStamp now =
|
|
presContext->RefreshDriver()->IsTestControllingRefreshesEnabled()
|
|
? presContext->RefreshDriver()->MostRecentRefresh()
|
|
: TimeStamp::Now();
|
|
bool isSmoothScroll =
|
|
aMode == ScrollMode::Smooth && IsSmoothScrollingEnabled();
|
|
|
|
nsSize currentVelocity(0, 0);
|
|
|
|
if (StaticPrefs::layout_css_scroll_behavior_enabled()) {
|
|
if (aMode == ScrollMode::SmoothMsd) {
|
|
mIgnoreMomentumScroll = true;
|
|
if (!mAsyncSmoothMSDScroll) {
|
|
nsPoint sv = mVelocityQueue.GetVelocity();
|
|
currentVelocity.width = sv.x;
|
|
currentVelocity.height = sv.y;
|
|
if (mAsyncScroll) {
|
|
if (mAsyncScroll->IsSmoothScroll()) {
|
|
currentVelocity = mAsyncScroll->VelocityAt(now);
|
|
}
|
|
mAsyncScroll = nullptr;
|
|
}
|
|
|
|
if (nsLayoutUtils::AsyncPanZoomEnabled(mOuter) && WantAsyncScroll()) {
|
|
ApzSmoothScrollTo(mDestination, aOrigin);
|
|
return;
|
|
}
|
|
|
|
mAsyncSmoothMSDScroll = new AsyncSmoothMSDScroll(
|
|
GetScrollPosition(), mDestination, currentVelocity,
|
|
GetLayoutScrollRange(), now, presContext);
|
|
|
|
mAsyncSmoothMSDScroll->SetRefreshObserver(this);
|
|
} else {
|
|
// A previous smooth MSD scroll is still in progress, so we just need to
|
|
// update its range and destination.
|
|
mAsyncSmoothMSDScroll->SetRange(GetLayoutScrollRange());
|
|
mAsyncSmoothMSDScroll->SetDestination(mDestination);
|
|
}
|
|
|
|
return;
|
|
} else {
|
|
if (mAsyncSmoothMSDScroll) {
|
|
currentVelocity = mAsyncSmoothMSDScroll->GetVelocity();
|
|
mAsyncSmoothMSDScroll = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mAsyncScroll) {
|
|
mAsyncScroll = new AsyncScroll();
|
|
mAsyncScroll->SetRefreshObserver(this);
|
|
}
|
|
|
|
if (isSmoothScroll) {
|
|
mAsyncScroll->InitSmoothScroll(now, GetScrollPosition(), mDestination,
|
|
aOrigin, range, currentVelocity);
|
|
} else {
|
|
mAsyncScroll->Init(range);
|
|
}
|
|
}
|
|
|
|
// We can't use nsContainerFrame::PositionChildViews here because
|
|
// we don't want to invalidate views that have moved.
|
|
static void AdjustViews(nsIFrame* aFrame) {
|
|
nsView* view = aFrame->GetView();
|
|
if (view) {
|
|
nsPoint pt;
|
|
aFrame->GetParent()->GetClosestView(&pt);
|
|
pt += aFrame->GetPosition();
|
|
view->SetPosition(pt.x, pt.y);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!aFrame->HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW)) {
|
|
return;
|
|
}
|
|
|
|
// Call AdjustViews recursively for all child frames except the popup list as
|
|
// the views for popups are not scrolled.
|
|
for (const auto& [list, listID] : aFrame->ChildLists()) {
|
|
if (listID == nsIFrame::kPopupList) {
|
|
continue;
|
|
}
|
|
for (nsIFrame* child : list) {
|
|
AdjustViews(child);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::MarkScrollbarsDirtyForReflow() const {
|
|
PresShell* presShell = mOuter->PresShell();
|
|
if (mVScrollbarBox) {
|
|
presShell->FrameNeedsReflow(mVScrollbarBox, IntrinsicDirty::Resize,
|
|
NS_FRAME_IS_DIRTY);
|
|
}
|
|
if (mHScrollbarBox) {
|
|
presShell->FrameNeedsReflow(mHScrollbarBox, IntrinsicDirty::Resize,
|
|
NS_FRAME_IS_DIRTY);
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::InvalidateVerticalScrollbar() const {
|
|
if (mVScrollbarBox) {
|
|
mVScrollbarBox->InvalidateFrameSubtree();
|
|
}
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsAlwaysActive() const {
|
|
if (nsDisplayItem::ForceActiveLayers()) {
|
|
return true;
|
|
}
|
|
|
|
// Unless this is the root scrollframe for a non-chrome document
|
|
// which is the direct child of a chrome document, we default to not
|
|
// being "active".
|
|
if (!(mIsRoot && mOuter->PresContext()->IsRootContentDocument())) {
|
|
return false;
|
|
}
|
|
|
|
// If we have scrolled before, then we should stay active.
|
|
if (mHasBeenScrolled) {
|
|
return true;
|
|
}
|
|
|
|
// If we're overflow:hidden, then start as inactive until
|
|
// we get scrolled manually.
|
|
ScrollStyles styles = GetScrollStylesFromFrame();
|
|
return (styles.mHorizontal != StyleOverflow::Hidden &&
|
|
styles.mVertical != StyleOverflow::Hidden);
|
|
}
|
|
|
|
static void RemoveDisplayPortCallback(nsITimer* aTimer, void* aClosure) {
|
|
ScrollFrameHelper* helper = static_cast<ScrollFrameHelper*>(aClosure);
|
|
|
|
// This function only ever gets called from the expiry timer, so it must
|
|
// be non-null here. Set it to null here so that we don't keep resetting
|
|
// it unnecessarily in MarkRecentlyScrolled().
|
|
MOZ_ASSERT(helper->mDisplayPortExpiryTimer);
|
|
helper->mDisplayPortExpiryTimer = nullptr;
|
|
|
|
if (!helper->AllowDisplayPortExpiration() ||
|
|
helper->mIsParentToActiveScrollFrames) {
|
|
// If this is a scroll parent for some other scrollable frame, don't
|
|
// expire the displayport because it would break scroll handoff. Once the
|
|
// descendant scrollframes have their displayports expired, they will
|
|
// trigger the displayport expiration on this scrollframe as well, and
|
|
// mIsParentToActiveScrollFrames will presumably be false when that kicks
|
|
// in.
|
|
return;
|
|
}
|
|
|
|
// Remove the displayport from this scrollframe if it's been a while
|
|
// since it's scrolled, except if it needs to be always active. Note that
|
|
// there is one scrollframe that doesn't fall under this general rule, and
|
|
// that is the one that nsLayoutUtils::MaybeCreateDisplayPort decides to put
|
|
// a displayport on (i.e. the first scrollframe that WantAsyncScroll()s).
|
|
// If that scrollframe is this one, we remove the displayport anyway, and
|
|
// as part of the next paint MaybeCreateDisplayPort will put another
|
|
// displayport back on it. Although the displayport will "flicker" off and
|
|
// back on, the layer itself should never disappear, because this all
|
|
// happens between actual painting. If the displayport is reset to a
|
|
// different position that's ok; this scrollframe hasn't been scrolled
|
|
// recently and so the reset should be correct.
|
|
|
|
nsIContent* content = helper->mOuter->GetContent();
|
|
|
|
if (ScrollFrameHelper::ShouldActivateAllScrollFrames()) {
|
|
// If we are activating all scroll frames then we only want to remove the
|
|
// regular display port and downgrade to a minimal display port.
|
|
MOZ_ASSERT(!content->GetProperty(nsGkAtoms::MinimalDisplayPort));
|
|
content->SetProperty(nsGkAtoms::MinimalDisplayPort,
|
|
reinterpret_cast<void*>(true));
|
|
} else {
|
|
content->RemoveProperty(nsGkAtoms::MinimalDisplayPort);
|
|
DisplayPortUtils::RemoveDisplayPort(content);
|
|
// Be conservative and unflag this this scrollframe as being scrollable by
|
|
// APZ. If it is still scrollable this will get flipped back soon enough.
|
|
helper->mScrollableByAPZ = false;
|
|
}
|
|
|
|
DisplayPortUtils::ExpireDisplayPortOnAsyncScrollableAncestor(helper->mOuter);
|
|
|
|
helper->mOuter->SchedulePaint();
|
|
}
|
|
|
|
void ScrollFrameHelper::MarkEverScrolled() {
|
|
// Mark this frame as having been scrolled. If this is the root
|
|
// scroll frame of a content document, then IsAlwaysActive()
|
|
// will return true from now on and MarkNotRecentlyScrolled() won't
|
|
// have any effect.
|
|
mHasBeenScrolled = true;
|
|
}
|
|
|
|
void ScrollFrameHelper::MarkNotRecentlyScrolled() {
|
|
if (!mHasBeenScrolledRecently) return;
|
|
|
|
mHasBeenScrolledRecently = false;
|
|
mOuter->SchedulePaint();
|
|
}
|
|
|
|
void ScrollFrameHelper::MarkRecentlyScrolled() {
|
|
mHasBeenScrolledRecently = true;
|
|
if (IsAlwaysActive()) {
|
|
return;
|
|
}
|
|
|
|
if (mActivityExpirationState.IsTracked()) {
|
|
gScrollFrameActivityTracker->MarkUsed(this);
|
|
} else {
|
|
if (!gScrollFrameActivityTracker) {
|
|
gScrollFrameActivityTracker =
|
|
new ScrollFrameActivityTracker(GetMainThreadSerialEventTarget());
|
|
}
|
|
gScrollFrameActivityTracker->AddObject(this);
|
|
}
|
|
|
|
// If we just scrolled and there's a displayport expiry timer in place,
|
|
// reset the timer.
|
|
ResetDisplayPortExpiryTimer();
|
|
}
|
|
|
|
void ScrollFrameHelper::ResetDisplayPortExpiryTimer() {
|
|
if (mDisplayPortExpiryTimer) {
|
|
mDisplayPortExpiryTimer->InitWithNamedFuncCallback(
|
|
RemoveDisplayPortCallback, this,
|
|
StaticPrefs::apz_displayport_expiry_ms(), nsITimer::TYPE_ONE_SHOT,
|
|
"ScrollFrameHelper::ResetDisplayPortExpiryTimer");
|
|
}
|
|
}
|
|
|
|
bool ScrollFrameHelper::AllowDisplayPortExpiration() {
|
|
if (IsAlwaysActive()) {
|
|
return false;
|
|
}
|
|
if (mIsRoot && mOuter->PresContext()->IsRoot()) {
|
|
return false;
|
|
}
|
|
if (ShouldActivateAllScrollFrames() &&
|
|
mOuter->GetContent()->GetProperty(nsGkAtoms::MinimalDisplayPort)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ScrollFrameHelper::TriggerDisplayPortExpiration() {
|
|
if (!AllowDisplayPortExpiration()) {
|
|
return;
|
|
}
|
|
|
|
if (!StaticPrefs::apz_displayport_expiry_ms()) {
|
|
// a zero time disables the expiry
|
|
return;
|
|
}
|
|
|
|
if (!mDisplayPortExpiryTimer) {
|
|
mDisplayPortExpiryTimer = NS_NewTimer();
|
|
}
|
|
ResetDisplayPortExpiryTimer();
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollVisual() {
|
|
MarkEverScrolled();
|
|
|
|
AdjustViews(mScrolledFrame);
|
|
// We need to call this after fixing up the view positions
|
|
// to be consistent with the frame hierarchy.
|
|
MarkRecentlyScrolled();
|
|
}
|
|
|
|
/**
|
|
* Clamp desired scroll position aDesired and range [aDestLower, aDestUpper]
|
|
* to [aBoundLower, aBoundUpper] and then select the appunit value from among
|
|
* aBoundLower, aBoundUpper and those such that (aDesired - aCurrent) *
|
|
* aRes/aAppUnitsPerPixel is an integer (or as close as we can get
|
|
* modulo rounding to appunits) that is in [aDestLower, aDestUpper] and
|
|
* closest to aDesired. If no such value exists, return the nearest in
|
|
* [aDestLower, aDestUpper].
|
|
*/
|
|
static nscoord ClampAndAlignWithPixels(nscoord aDesired, nscoord aBoundLower,
|
|
nscoord aBoundUpper, nscoord aDestLower,
|
|
nscoord aDestUpper,
|
|
nscoord aAppUnitsPerPixel, double aRes,
|
|
nscoord aCurrent) {
|
|
// Intersect scroll range with allowed range, by clamping the ends
|
|
// of aRange to be within bounds
|
|
nscoord destLower = clamped(aDestLower, aBoundLower, aBoundUpper);
|
|
nscoord destUpper = clamped(aDestUpper, aBoundLower, aBoundUpper);
|
|
|
|
nscoord desired = clamped(aDesired, destLower, destUpper);
|
|
|
|
double currentLayerVal = (aRes * aCurrent) / aAppUnitsPerPixel;
|
|
double desiredLayerVal = (aRes * desired) / aAppUnitsPerPixel;
|
|
double delta = desiredLayerVal - currentLayerVal;
|
|
double nearestLayerVal = NS_round(delta) + currentLayerVal;
|
|
|
|
// Convert back from PaintedLayer space to appunits relative to the top-left
|
|
// of the scrolled frame.
|
|
nscoord aligned =
|
|
aRes == 0.0
|
|
? 0.0
|
|
: NSToCoordRoundWithClamp(nearestLayerVal * aAppUnitsPerPixel / aRes);
|
|
|
|
// Use a bound if it is within the allowed range and closer to desired than
|
|
// the nearest pixel-aligned value.
|
|
if (aBoundUpper == destUpper &&
|
|
static_cast<decltype(Abs(desired))>(aBoundUpper - desired) <
|
|
Abs(desired - aligned)) {
|
|
return aBoundUpper;
|
|
}
|
|
|
|
if (aBoundLower == destLower &&
|
|
static_cast<decltype(Abs(desired))>(desired - aBoundLower) <
|
|
Abs(aligned - desired)) {
|
|
return aBoundLower;
|
|
}
|
|
|
|
// Accept the nearest pixel-aligned value if it is within the allowed range.
|
|
if (aligned >= destLower && aligned <= destUpper) {
|
|
return aligned;
|
|
}
|
|
|
|
// Check if opposite pixel boundary fits into allowed range.
|
|
double oppositeLayerVal =
|
|
nearestLayerVal + ((nearestLayerVal < desiredLayerVal) ? 1.0 : -1.0);
|
|
nscoord opposite = aRes == 0.0
|
|
? 0.0
|
|
: NSToCoordRoundWithClamp(oppositeLayerVal *
|
|
aAppUnitsPerPixel / aRes);
|
|
if (opposite >= destLower && opposite <= destUpper) {
|
|
return opposite;
|
|
}
|
|
|
|
// No alignment available.
|
|
return desired;
|
|
}
|
|
|
|
/**
|
|
* Clamp desired scroll position aPt to aBounds and then snap
|
|
* it to the same layer pixel edges as aCurrent, keeping it within aRange
|
|
* during snapping. aCurrent is the current scroll position.
|
|
*/
|
|
static nsPoint ClampAndAlignWithLayerPixels(
|
|
const nsPoint& aPt, const nsRect& aBounds, const nsRect& aRange,
|
|
const nsPoint& aCurrent, nscoord aAppUnitsPerPixel, const gfxSize& aScale) {
|
|
return nsPoint(
|
|
ClampAndAlignWithPixels(aPt.x, aBounds.x, aBounds.XMost(), aRange.x,
|
|
aRange.XMost(), aAppUnitsPerPixel, aScale.width,
|
|
aCurrent.x),
|
|
ClampAndAlignWithPixels(aPt.y, aBounds.y, aBounds.YMost(), aRange.y,
|
|
aRange.YMost(), aAppUnitsPerPixel, aScale.height,
|
|
aCurrent.y));
|
|
}
|
|
|
|
/* static */
|
|
void ScrollFrameHelper::ScrollActivityCallback(nsITimer* aTimer,
|
|
void* anInstance) {
|
|
ScrollFrameHelper* self = static_cast<ScrollFrameHelper*>(anInstance);
|
|
|
|
// Fire the synth mouse move.
|
|
self->mScrollActivityTimer->Cancel();
|
|
self->mScrollActivityTimer = nullptr;
|
|
self->mOuter->PresShell()->SynthesizeMouseMove(true);
|
|
}
|
|
|
|
void ScrollFrameHelper::ScheduleSyntheticMouseMove() {
|
|
if (!mScrollActivityTimer) {
|
|
mScrollActivityTimer = NS_NewTimer(
|
|
mOuter->PresContext()->Document()->EventTargetFor(TaskCategory::Other));
|
|
if (!mScrollActivityTimer) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
mScrollActivityTimer->InitWithNamedFuncCallback(
|
|
ScrollActivityCallback, this, 100, nsITimer::TYPE_ONE_SHOT,
|
|
"ScrollFrameHelper::ScheduleSyntheticMouseMove");
|
|
}
|
|
|
|
void ScrollFrameHelper::NotifyApproximateFrameVisibilityUpdate(
|
|
bool aIgnoreDisplayPort) {
|
|
mLastUpdateFramesPos = GetScrollPosition();
|
|
if (aIgnoreDisplayPort) {
|
|
mHadDisplayPortAtLastFrameUpdate = false;
|
|
mDisplayPortAtLastFrameUpdate = nsRect();
|
|
} else {
|
|
mHadDisplayPortAtLastFrameUpdate = DisplayPortUtils::GetDisplayPort(
|
|
mOuter->GetContent(), &mDisplayPortAtLastFrameUpdate);
|
|
}
|
|
}
|
|
|
|
bool ScrollFrameHelper::GetDisplayPortAtLastApproximateFrameVisibilityUpdate(
|
|
nsRect* aDisplayPort) {
|
|
if (mHadDisplayPortAtLastFrameUpdate) {
|
|
*aDisplayPort = mDisplayPortAtLastFrameUpdate;
|
|
}
|
|
return mHadDisplayPortAtLastFrameUpdate;
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollToImpl(nsPoint aPt, const nsRect& aRange,
|
|
ScrollOrigin aOrigin) {
|
|
// None is never a valid scroll origin to be passed in.
|
|
MOZ_ASSERT(aOrigin != ScrollOrigin::None);
|
|
|
|
// Figure out the effective origin for this scroll request.
|
|
if (aOrigin == ScrollOrigin::NotSpecified) {
|
|
// If no origin was specified, we still want to set it to something that's
|
|
// non-unknown, so that we can use eUnknown to distinguish if the frame was
|
|
// scrolled at all. Default it to some generic placeholder.
|
|
aOrigin = ScrollOrigin::Other;
|
|
}
|
|
|
|
// If this scroll is |relative|, but we've already had a user scroll that
|
|
// was not relative, promote this origin to |other|. This ensures that we
|
|
// may only transmit a relative update to APZ if all scrolls since the last
|
|
// transaction or repaint request have been relative.
|
|
if (aOrigin == ScrollOrigin::Relative &&
|
|
(mLastScrollOrigin != ScrollOrigin::None &&
|
|
mLastScrollOrigin != ScrollOrigin::NotSpecified &&
|
|
mLastScrollOrigin != ScrollOrigin::Relative &&
|
|
mLastScrollOrigin != ScrollOrigin::Apz)) {
|
|
aOrigin = ScrollOrigin::Other;
|
|
}
|
|
|
|
// If the origin is a downgrade, and downgrades are allowed, process the
|
|
// downgrade even if we're going to early-exit because we're already at
|
|
// the correct scroll position. This ensures that if there wasn't a main-
|
|
// thread scroll update pending before a frame reconstruction (as indicated
|
|
// by mAllowScrollOriginDowngrade=true), then after the frame reconstruction
|
|
// the origin is downgraded to "restore" even if the layout scroll offset to
|
|
// be restored is (0,0) (which will take the early-exit below). This is
|
|
// important so that restoration of a *visual* scroll offset (which might be
|
|
// to something other than (0,0)) isn't clobbered.
|
|
bool isScrollOriginDowngrade =
|
|
nsLayoutUtils::CanScrollOriginClobberApz(mLastScrollOrigin) &&
|
|
!nsLayoutUtils::CanScrollOriginClobberApz(aOrigin);
|
|
bool allowScrollOriginChange =
|
|
mAllowScrollOriginDowngrade && isScrollOriginDowngrade;
|
|
|
|
if (allowScrollOriginChange) {
|
|
mLastScrollOrigin = aOrigin;
|
|
mAllowScrollOriginDowngrade = false;
|
|
}
|
|
|
|
nsPresContext* presContext = mOuter->PresContext();
|
|
nscoord appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
|
|
// 'scale' is our estimate of the scale factor that will be applied
|
|
// when rendering the scrolled content to its own PaintedLayer.
|
|
gfxSize scale =
|
|
FrameLayerBuilder::GetPaintedLayerScaleForFrame(mScrolledFrame);
|
|
nsPoint curPos = GetScrollPosition();
|
|
|
|
nsPoint alignWithPos = mScrollPosForLayerPixelAlignment == nsPoint(-1, -1)
|
|
? curPos
|
|
: mScrollPosForLayerPixelAlignment;
|
|
// Try to align aPt with curPos so they have an integer number of layer
|
|
// pixels between them. This gives us the best chance of scrolling without
|
|
// having to invalidate due to changes in subpixel rendering.
|
|
// Note that when we actually draw into a PaintedLayer, the coordinates
|
|
// that get mapped onto the layer buffer pixels are from the display list,
|
|
// which are relative to the display root frame's top-left increasing down,
|
|
// whereas here our coordinates are scroll positions which increase upward
|
|
// and are relative to the scrollport top-left. This difference doesn't
|
|
// actually matter since all we are about is that there be an integer number
|
|
// of layer pixels between pt and curPos.
|
|
nsPoint pt =
|
|
ClampAndAlignWithLayerPixels(aPt, GetLayoutScrollRange(), aRange,
|
|
alignWithPos, appUnitsPerDevPixel, scale);
|
|
if (pt == curPos) {
|
|
// Even if we are bailing out due to no-op main-thread scroll position
|
|
// change, we might need to cancel an APZ smooth scroll that we already
|
|
// kicked off. It might be reasonable to eventually remove the
|
|
// mApzSmoothScrollDestination clause from this if statement, as that
|
|
// may simplify this a bit and should be fine from the APZ side.
|
|
if (mApzSmoothScrollDestination && aOrigin != ScrollOrigin::Clamp) {
|
|
if (aOrigin == ScrollOrigin::Relative) {
|
|
AppendScrollUpdate(
|
|
ScrollPositionUpdate::NewRelativeScroll(mApzScrollPos, pt));
|
|
mApzScrollPos = pt;
|
|
} else if (aOrigin != ScrollOrigin::Apz) {
|
|
ScrollOrigin origin =
|
|
(mAllowScrollOriginDowngrade || !isScrollOriginDowngrade)
|
|
? aOrigin
|
|
: mLastScrollOrigin;
|
|
AppendScrollUpdate(ScrollPositionUpdate::NewScroll(origin, pt));
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If we are scrolling the RCD-RSF, and a visual scroll update is pending,
|
|
// cancel it; otherwise, it will clobber this scroll.
|
|
if (IsRootScrollFrameOfDocument() && presContext->IsRootContentDocument()) {
|
|
PresShell* ps = presContext->GetPresShell();
|
|
if (const auto& visualScrollUpdate = ps->GetPendingVisualScrollUpdate()) {
|
|
if (visualScrollUpdate->mVisualScrollOffset != aPt) {
|
|
// Only clobber if the scroll was originated by the main thread.
|
|
// Respect the priority of origins (an "eRestore" layout scroll should
|
|
// not clobber an "eMainThread" visual scroll.)
|
|
bool shouldClobber =
|
|
aOrigin == ScrollOrigin::Other ||
|
|
(aOrigin == ScrollOrigin::Restore &&
|
|
visualScrollUpdate->mUpdateType == FrameMetrics::eRestore);
|
|
if (shouldClobber) {
|
|
ps->AcknowledgePendingVisualScrollUpdate();
|
|
ps->ClearPendingVisualScrollUpdate();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool needFrameVisibilityUpdate = mLastUpdateFramesPos == nsPoint(-1, -1);
|
|
|
|
nsPoint dist(std::abs(pt.x - mLastUpdateFramesPos.x),
|
|
std::abs(pt.y - mLastUpdateFramesPos.y));
|
|
nsSize visualViewportSize = GetVisualViewportSize();
|
|
nscoord horzAllowance = std::max(
|
|
visualViewportSize.width /
|
|
std::max(
|
|
StaticPrefs::
|
|
layout_framevisibility_amountscrollbeforeupdatehorizontal(),
|
|
1),
|
|
AppUnitsPerCSSPixel());
|
|
nscoord vertAllowance = std::max(
|
|
visualViewportSize.height /
|
|
std::max(
|
|
StaticPrefs::
|
|
layout_framevisibility_amountscrollbeforeupdatevertical(),
|
|
1),
|
|
AppUnitsPerCSSPixel());
|
|
if (dist.x >= horzAllowance || dist.y >= vertAllowance) {
|
|
needFrameVisibilityUpdate = true;
|
|
}
|
|
|
|
// notify the listeners.
|
|
for (uint32_t i = 0; i < mListeners.Length(); i++) {
|
|
mListeners[i]->ScrollPositionWillChange(pt.x, pt.y);
|
|
}
|
|
|
|
nsRect oldDisplayPort;
|
|
nsIContent* content = mOuter->GetContent();
|
|
DisplayPortUtils::GetHighResolutionDisplayPort(content, &oldDisplayPort);
|
|
oldDisplayPort.MoveBy(-mScrolledFrame->GetPosition());
|
|
|
|
// Update frame position for scrolling
|
|
mScrolledFrame->SetPosition(mScrollPort.TopLeft() - pt);
|
|
|
|
// If |mLastScrollOrigin| is already set to something that can clobber APZ's
|
|
// scroll offset, then we don't want to change it to something that can't.
|
|
// If we allowed this, then we could end up in a state where APZ ignores
|
|
// legitimate scroll offset updates because the origin has been masked by
|
|
// a later change within the same refresh driver tick.
|
|
allowScrollOriginChange =
|
|
(mAllowScrollOriginDowngrade || !isScrollOriginDowngrade);
|
|
|
|
if (allowScrollOriginChange) {
|
|
mLastScrollOrigin = aOrigin;
|
|
mAllowScrollOriginDowngrade = false;
|
|
}
|
|
|
|
if (aOrigin == ScrollOrigin::Relative) {
|
|
MOZ_ASSERT(!isScrollOriginDowngrade);
|
|
MOZ_ASSERT(mLastScrollOrigin == ScrollOrigin::Relative);
|
|
AppendScrollUpdate(
|
|
ScrollPositionUpdate::NewRelativeScroll(mApzScrollPos, pt));
|
|
mApzScrollPos = pt;
|
|
} else if (aOrigin != ScrollOrigin::Apz) {
|
|
AppendScrollUpdate(ScrollPositionUpdate::NewScroll(mLastScrollOrigin, pt));
|
|
}
|
|
|
|
if (mLastScrollOrigin == ScrollOrigin::Apz) {
|
|
mApzScrollPos = GetScrollPosition();
|
|
}
|
|
|
|
ScrollVisual();
|
|
mAnchor.UserScrolled();
|
|
|
|
bool schedulePaint = true;
|
|
if (nsLayoutUtils::AsyncPanZoomEnabled(mOuter) &&
|
|
!nsLayoutUtils::ShouldDisableApzForElement(content) &&
|
|
!content->GetProperty(nsGkAtoms::MinimalDisplayPort) &&
|
|
StaticPrefs::apz_paint_skipping_enabled()) {
|
|
// If APZ is enabled with paint-skipping, there are certain conditions in
|
|
// which we can skip paints:
|
|
// 1) If APZ triggered this scroll, and the tile-aligned displayport is
|
|
// unchanged.
|
|
// 2) If non-APZ triggered this scroll, but we can handle it by just asking
|
|
// APZ to update the scroll position. Again we make this conditional on
|
|
// the tile-aligned displayport being unchanged.
|
|
// We do the displayport check first since it's common to all scenarios,
|
|
// and then if the displayport is unchanged, we check if APZ triggered,
|
|
// or can handle, this scroll. If so, we set schedulePaint to false and
|
|
// skip the paint.
|
|
// Because of bug 1264297, we also don't do paint-skipping for elements with
|
|
// perspective, because the displayport may not have captured everything
|
|
// that needs to be painted. So even if the final tile-aligned displayport
|
|
// is the same, we force a repaint for these elements. Bug 1254260 tracks
|
|
// fixing this properly.
|
|
nsRect displayPort;
|
|
bool usingDisplayPort =
|
|
DisplayPortUtils::GetHighResolutionDisplayPort(content, &displayPort);
|
|
displayPort.MoveBy(-mScrolledFrame->GetPosition());
|
|
|
|
PAINT_SKIP_LOG(
|
|
"New scrollpos %s usingDP %d dpEqual %d scrollableByApz "
|
|
"%d perspective %d bglocal %d filter %d\n",
|
|
ToString(CSSPoint::FromAppUnits(GetScrollPosition())).c_str(),
|
|
usingDisplayPort, displayPort.IsEqualEdges(oldDisplayPort),
|
|
mScrollableByAPZ, HasPerspective(), HasBgAttachmentLocal(),
|
|
mHasOutOfFlowContentInsideFilter);
|
|
if (usingDisplayPort && displayPort.IsEqualEdges(oldDisplayPort) &&
|
|
!HasPerspective() && !HasBgAttachmentLocal() &&
|
|
!mHasOutOfFlowContentInsideFilter) {
|
|
bool haveScrollLinkedEffects =
|
|
content->GetComposedDoc()->HasScrollLinkedEffect();
|
|
bool apzDisabled = haveScrollLinkedEffects &&
|
|
StaticPrefs::apz_disable_for_scroll_linked_effects();
|
|
if (!apzDisabled) {
|
|
if (LastScrollOrigin() == ScrollOrigin::Apz) {
|
|
schedulePaint = false;
|
|
PAINT_SKIP_LOG("Skipping due to APZ scroll\n");
|
|
} else if (mScrollableByAPZ) {
|
|
nsIWidget* widget = presContext->GetNearestWidget();
|
|
LayerManager* manager = widget ? widget->GetLayerManager() : nullptr;
|
|
if (manager) {
|
|
mozilla::layers::ScrollableLayerGuid::ViewID id;
|
|
bool success = nsLayoutUtils::FindIDFor(content, &id);
|
|
MOZ_ASSERT(success); // we have a displayport, we better have an ID
|
|
|
|
// Schedule an empty transaction to carry over the scroll offset
|
|
// update, instead of a full transaction. This empty transaction
|
|
// might still get squashed into a full transaction if something
|
|
// happens to trigger one.
|
|
MOZ_ASSERT(!mScrollUpdates.IsEmpty());
|
|
success = manager->AddPendingScrollUpdateForNextTransaction(
|
|
id, mScrollUpdates.LastElement());
|
|
if (success) {
|
|
schedulePaint = false;
|
|
mOuter->SchedulePaint(nsIFrame::PAINT_COMPOSITE_ONLY);
|
|
PAINT_SKIP_LOG(
|
|
"Skipping due to APZ-forwarded main-thread scroll\n");
|
|
} else {
|
|
PAINT_SKIP_LOG(
|
|
"Failed to set pending scroll update on layer manager\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the new scroll offset is going to clobber APZ's scroll offset, for
|
|
// the RCD-RSF this will have the effect of updating the visual viewport
|
|
// offset in a way that keeps the relative offset between the layout and
|
|
// visual viewports constant. This will cause APZ to send us a new visual
|
|
// viewport offset, but instead of waiting for that, just set the value
|
|
// we expect APZ will set ourselves, to minimize the chances of
|
|
// inconsistencies from querying a stale value.
|
|
if (mIsRoot && nsLayoutUtils::CanScrollOriginClobberApz(mLastScrollOrigin)) {
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
AutoScrollbarRepaintSuppression repaintSuppression(this, weakFrame,
|
|
!schedulePaint);
|
|
|
|
nsPoint relativeOffset =
|
|
presContext->PresShell()->GetVisualViewportOffset() - curPos;
|
|
presContext->PresShell()->SetVisualViewportOffset(pt + relativeOffset,
|
|
curPos);
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (schedulePaint) {
|
|
mOuter->SchedulePaint();
|
|
|
|
if (needFrameVisibilityUpdate) {
|
|
presContext->PresShell()->ScheduleApproximateFrameVisibilityUpdateNow();
|
|
}
|
|
}
|
|
|
|
if (mOuter->ChildrenHavePerspective()) {
|
|
// The overflow areas of descendants may depend on the scroll position,
|
|
// so ensure they get updated.
|
|
|
|
// First we recompute the overflow areas of the transformed children
|
|
// that use the perspective. FinishAndStoreOverflow only calls this
|
|
// if the size changes, so we need to do it manually.
|
|
mOuter->RecomputePerspectiveChildrenOverflow(mOuter);
|
|
|
|
// Update the overflow for the scrolled frame to take any changes from the
|
|
// children into account.
|
|
mScrolledFrame->UpdateOverflow();
|
|
|
|
// Update the overflow for the outer so that we recompute scrollbars.
|
|
mOuter->UpdateOverflow();
|
|
}
|
|
|
|
ScheduleSyntheticMouseMove();
|
|
|
|
PresShell::AutoAssertNoFlush noFlush(*mOuter->PresShell());
|
|
|
|
{ // scope the AutoScrollbarRepaintSuppression
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
AutoScrollbarRepaintSuppression repaintSuppression(this, weakFrame,
|
|
!schedulePaint);
|
|
UpdateScrollbarPosition();
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
presContext->RecordInteractionTime(
|
|
nsPresContext::InteractionType::ScrollInteraction, TimeStamp::Now());
|
|
|
|
PostScrollEvent();
|
|
// If this is a viewport scroll, this could affect the relative offset
|
|
// between layout and visual viewport, so we might have to fire a visual
|
|
// viewport scroll event as well.
|
|
if (mIsRoot) {
|
|
if (auto* window = nsGlobalWindowInner::Cast(
|
|
mOuter->PresContext()->Document()->GetInnerWindow())) {
|
|
window->VisualViewport()->PostScrollEvent(
|
|
presContext->PresShell()->GetVisualViewportOffset(), curPos);
|
|
}
|
|
}
|
|
|
|
// notify the listeners.
|
|
for (uint32_t i = 0; i < mListeners.Length(); i++) {
|
|
mListeners[i]->ScrollPositionDidChange(pt.x, pt.y);
|
|
}
|
|
|
|
if (nsCOMPtr<nsIDocShell> docShell = presContext->GetDocShell()) {
|
|
docShell->NotifyScrollObservers();
|
|
}
|
|
}
|
|
|
|
static Maybe<int32_t> MaxZIndexInList(nsDisplayList* aList,
|
|
nsDisplayListBuilder* aBuilder) {
|
|
Maybe<int32_t> maxZIndex = Nothing();
|
|
for (nsDisplayItem* item = aList->GetBottom(); item;
|
|
item = item->GetAbove()) {
|
|
int32_t zIndex = item->ZIndex();
|
|
if (zIndex < 0) {
|
|
continue;
|
|
}
|
|
if (!maxZIndex) {
|
|
maxZIndex = Some(zIndex);
|
|
} else {
|
|
maxZIndex = Some(std::max(maxZIndex.value(), zIndex));
|
|
}
|
|
}
|
|
return maxZIndex;
|
|
}
|
|
|
|
template <class T>
|
|
static void AppendInternalItemToTop(const nsDisplayListSet& aLists, T* aItem,
|
|
const Maybe<int32_t>& aZIndex) {
|
|
if (aZIndex) {
|
|
aItem->SetOverrideZIndex(aZIndex.value());
|
|
aLists.PositionedDescendants()->AppendToTop(aItem);
|
|
} else {
|
|
aLists.Content()->AppendToTop(aItem);
|
|
}
|
|
}
|
|
|
|
static const uint32_t APPEND_OWN_LAYER = 0x1;
|
|
static const uint32_t APPEND_POSITIONED = 0x2;
|
|
static const uint32_t APPEND_SCROLLBAR_CONTAINER = 0x4;
|
|
static const uint32_t APPEND_OVERLAY = 0x8;
|
|
static const uint32_t APPEND_TOP = 0x10;
|
|
|
|
static void AppendToTop(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists, nsDisplayList* aSource,
|
|
nsIFrame* aSourceFrame, uint32_t aFlags) {
|
|
if (aSource->IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
nsDisplayWrapList* newItem;
|
|
const ActiveScrolledRoot* asr = aBuilder->CurrentActiveScrolledRoot();
|
|
if (aFlags & APPEND_OWN_LAYER) {
|
|
ScrollbarData scrollbarData;
|
|
if (aFlags & APPEND_SCROLLBAR_CONTAINER) {
|
|
scrollbarData = ScrollbarData::CreateForScrollbarContainer(
|
|
aBuilder->GetCurrentScrollbarDirection(),
|
|
aBuilder->GetCurrentScrollbarTarget());
|
|
// Direction should be set
|
|
MOZ_ASSERT(scrollbarData.mDirection.isSome());
|
|
}
|
|
|
|
newItem = MakeDisplayItemWithIndex<nsDisplayOwnLayer>(
|
|
aBuilder, aSourceFrame,
|
|
/* aIndex = */ nsDisplayOwnLayer::OwnLayerForScrollbar, aSource, asr,
|
|
nsDisplayOwnLayerFlags::None, scrollbarData, true, false);
|
|
} else {
|
|
// Build the wrap list with an index of 1, since the scrollbar frame itself
|
|
// might have already built an nsDisplayWrapList.
|
|
newItem = MakeDisplayItemWithIndex<nsDisplayWrapList>(
|
|
aBuilder, aSourceFrame, 1, aSource, asr, false);
|
|
}
|
|
if (!newItem) {
|
|
return;
|
|
}
|
|
|
|
if (aFlags & APPEND_POSITIONED) {
|
|
// We want overlay scrollbars to always be on top of the scrolled content,
|
|
// but we don't want them to unnecessarily cover overlapping elements from
|
|
// outside our scroll frame.
|
|
Maybe<int32_t> zIndex = Nothing();
|
|
if (aFlags & APPEND_TOP) {
|
|
zIndex = Some(INT32_MAX);
|
|
} else if (aFlags & APPEND_OVERLAY) {
|
|
zIndex = MaxZIndexInList(aLists.PositionedDescendants(), aBuilder);
|
|
} else if (aSourceFrame->StylePosition()->mZIndex.IsInteger()) {
|
|
zIndex = Some(aSourceFrame->StylePosition()->mZIndex.integer._0);
|
|
}
|
|
AppendInternalItemToTop(aLists, newItem, zIndex);
|
|
} else {
|
|
aLists.BorderBackground()->AppendToTop(newItem);
|
|
}
|
|
}
|
|
|
|
struct HoveredStateComparator {
|
|
static bool Hovered(const nsIFrame* aFrame) {
|
|
return aFrame->GetContent()->IsElement() &&
|
|
aFrame->GetContent()->AsElement()->HasAttr(kNameSpaceID_None,
|
|
nsGkAtoms::hover);
|
|
}
|
|
|
|
bool Equals(nsIFrame* A, nsIFrame* B) const {
|
|
return Hovered(A) == Hovered(B);
|
|
}
|
|
|
|
bool LessThan(nsIFrame* A, nsIFrame* B) const {
|
|
return !Hovered(A) && Hovered(B);
|
|
}
|
|
};
|
|
|
|
void ScrollFrameHelper::AppendScrollPartsTo(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists,
|
|
bool aCreateLayer,
|
|
bool aPositioned) {
|
|
const bool overlayScrollbars =
|
|
LookAndFeel::GetInt(LookAndFeel::IntID::UseOverlayScrollbars) != 0;
|
|
|
|
AutoTArray<nsIFrame*, 3> scrollParts;
|
|
for (nsIFrame* kid : mOuter->PrincipalChildList()) {
|
|
if (kid == mScrolledFrame ||
|
|
(kid->IsAbsPosContainingBlock() || overlayScrollbars) != aPositioned) {
|
|
continue;
|
|
}
|
|
|
|
scrollParts.AppendElement(kid);
|
|
}
|
|
if (scrollParts.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
// We can't check will-change budget during display list building phase.
|
|
// This means that we will build scroll bar layers for out of budget
|
|
// will-change: scroll position.
|
|
const mozilla::layers::ScrollableLayerGuid::ViewID scrollTargetId =
|
|
IsMaybeScrollingActive()
|
|
? nsLayoutUtils::FindOrCreateIDFor(mScrolledFrame->GetContent())
|
|
: mozilla::layers::ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
|
|
scrollParts.Sort(HoveredStateComparator());
|
|
|
|
DisplayListClipState::AutoSaveRestore clipState(aBuilder);
|
|
// Don't let scrollparts extent outside our frame's border-box, if these are
|
|
// viewport scrollbars. They would create layerization problems. This wouldn't
|
|
// normally be an issue but themes can add overflow areas to scrollbar parts.
|
|
if (mIsRoot) {
|
|
nsRect scrollPartsClip(aBuilder->ToReferenceFrame(mOuter),
|
|
TrueOuterSize(aBuilder));
|
|
clipState.ClipContentDescendants(scrollPartsClip);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < scrollParts.Length(); ++i) {
|
|
Maybe<ScrollDirection> scrollDirection;
|
|
uint32_t appendToTopFlags = 0;
|
|
if (scrollParts[i] == mVScrollbarBox) {
|
|
scrollDirection.emplace(ScrollDirection::eVertical);
|
|
appendToTopFlags |= APPEND_SCROLLBAR_CONTAINER;
|
|
}
|
|
if (scrollParts[i] == mHScrollbarBox) {
|
|
MOZ_ASSERT(!scrollDirection.isSome());
|
|
scrollDirection.emplace(ScrollDirection::eHorizontal);
|
|
appendToTopFlags |= APPEND_SCROLLBAR_CONTAINER;
|
|
}
|
|
if (scrollParts[i] == mResizerBox && !HasResizer()) {
|
|
continue;
|
|
}
|
|
|
|
// The display port doesn't necessarily include the scrollbars, so just
|
|
// include all of the scrollbars if we are in a RCD-RSF. We only do
|
|
// this for the root scrollframe of the root content document, which is
|
|
// zoomable, and where the scrollbar sizes are bounded by the widget.
|
|
const nsRect visible =
|
|
mIsRoot && mOuter->PresContext()->IsRootContentDocument()
|
|
? scrollParts[i]->InkOverflowRectRelativeToParent()
|
|
: aBuilder->GetVisibleRect();
|
|
if (visible.IsEmpty()) {
|
|
continue;
|
|
}
|
|
const nsRect dirty =
|
|
mIsRoot && mOuter->PresContext()->IsRootContentDocument()
|
|
? scrollParts[i]->InkOverflowRectRelativeToParent()
|
|
: aBuilder->GetDirtyRect();
|
|
|
|
// Always create layers for overlay scrollbars so that we don't create a
|
|
// giant layer covering the whole scrollport if both scrollbars are visible.
|
|
const bool isOverlayScrollbar =
|
|
scrollDirection.isSome() && overlayScrollbars;
|
|
const bool createLayer =
|
|
aCreateLayer || isOverlayScrollbar ||
|
|
StaticPrefs::layout_scrollbars_always_layerize_track();
|
|
|
|
nsDisplayListCollection partList(aBuilder);
|
|
{
|
|
nsDisplayListBuilder::AutoBuildingDisplayList buildingForChild(
|
|
aBuilder, mOuter, visible, dirty);
|
|
|
|
nsDisplayListBuilder::AutoCurrentScrollbarInfoSetter infoSetter(
|
|
aBuilder, scrollTargetId, scrollDirection, createLayer);
|
|
mOuter->BuildDisplayListForChild(
|
|
aBuilder, scrollParts[i], partList,
|
|
nsIFrame::DisplayChildFlag::ForceStackingContext);
|
|
}
|
|
|
|
// DisplayChildFlag::ForceStackingContext put everything into
|
|
// partList.PositionedDescendants().
|
|
if (partList.PositionedDescendants()->IsEmpty()) {
|
|
continue;
|
|
}
|
|
|
|
if (createLayer) {
|
|
appendToTopFlags |= APPEND_OWN_LAYER;
|
|
}
|
|
if (aPositioned) {
|
|
appendToTopFlags |= APPEND_POSITIONED;
|
|
}
|
|
|
|
if (isOverlayScrollbar || scrollParts[i] == mResizerBox) {
|
|
if (isOverlayScrollbar && mIsRoot) {
|
|
appendToTopFlags |= APPEND_TOP;
|
|
} else {
|
|
appendToTopFlags |= APPEND_OVERLAY;
|
|
aBuilder->SetDisablePartialUpdates(true);
|
|
}
|
|
}
|
|
|
|
{
|
|
nsDisplayListBuilder::AutoBuildingDisplayList buildingForChild(
|
|
aBuilder, scrollParts[i],
|
|
visible + mOuter->GetOffsetTo(scrollParts[i]),
|
|
dirty + mOuter->GetOffsetTo(scrollParts[i]));
|
|
if (scrollParts[i]->IsTransformed()) {
|
|
nsPoint toOuterReferenceFrame;
|
|
const nsIFrame* outerReferenceFrame = aBuilder->FindReferenceFrameFor(
|
|
scrollParts[i]->GetParent(), &toOuterReferenceFrame);
|
|
toOuterReferenceFrame += scrollParts[i]->GetPosition();
|
|
|
|
buildingForChild.SetReferenceFrameAndCurrentOffset(
|
|
outerReferenceFrame, toOuterReferenceFrame);
|
|
}
|
|
nsDisplayListBuilder::AutoCurrentScrollbarInfoSetter infoSetter(
|
|
aBuilder, scrollTargetId, scrollDirection, createLayer);
|
|
|
|
::AppendToTop(aBuilder, aLists, partList.PositionedDescendants(),
|
|
scrollParts[i], appendToTopFlags);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::ExpandRectToNearlyVisible(const nsRect& aRect) const {
|
|
// We don't want to expand a rect in a direction that we can't scroll, so we
|
|
// check the scroll range.
|
|
nsRect scrollRange = GetLayoutScrollRange();
|
|
nsPoint scrollPos = GetScrollPosition();
|
|
nsMargin expand(0, 0, 0, 0);
|
|
|
|
nscoord vertShift =
|
|
StaticPrefs::layout_framevisibility_numscrollportheights() * aRect.height;
|
|
if (scrollRange.y < scrollPos.y) {
|
|
expand.top = vertShift;
|
|
}
|
|
if (scrollPos.y < scrollRange.YMost()) {
|
|
expand.bottom = vertShift;
|
|
}
|
|
|
|
nscoord horzShift =
|
|
StaticPrefs::layout_framevisibility_numscrollportwidths() * aRect.width;
|
|
if (scrollRange.x < scrollPos.x) {
|
|
expand.left = horzShift;
|
|
}
|
|
if (scrollPos.x < scrollRange.XMost()) {
|
|
expand.right = horzShift;
|
|
}
|
|
|
|
nsRect rect = aRect;
|
|
rect.Inflate(expand);
|
|
return rect;
|
|
}
|
|
|
|
static bool ShouldBeClippedByFrame(nsIFrame* aClipFrame,
|
|
nsIFrame* aClippedFrame) {
|
|
return nsLayoutUtils::IsProperAncestorFrame(aClipFrame, aClippedFrame);
|
|
}
|
|
|
|
static void ClipItemsExceptCaret(
|
|
nsDisplayList* aList, nsDisplayListBuilder* aBuilder, nsIFrame* aClipFrame,
|
|
const DisplayItemClipChain* aExtraClip,
|
|
nsTHashMap<nsPtrHashKey<const DisplayItemClipChain>,
|
|
const DisplayItemClipChain*>& aCache) {
|
|
for (nsDisplayItem* i = aList->GetBottom(); i; i = i->GetAbove()) {
|
|
if (!ShouldBeClippedByFrame(aClipFrame, i->Frame())) {
|
|
continue;
|
|
}
|
|
|
|
const DisplayItemType type = i->GetType();
|
|
if (type != DisplayItemType::TYPE_CARET &&
|
|
type != DisplayItemType::TYPE_CONTAINER) {
|
|
const DisplayItemClipChain* clip = i->GetClipChain();
|
|
const DisplayItemClipChain* intersection = nullptr;
|
|
if (aCache.Get(clip, &intersection)) {
|
|
i->SetClipChain(intersection, true);
|
|
} else {
|
|
i->IntersectClip(aBuilder, aExtraClip, true);
|
|
aCache.InsertOrUpdate(clip, i->GetClipChain());
|
|
}
|
|
}
|
|
nsDisplayList* children = i->GetSameCoordinateSystemChildren();
|
|
if (children) {
|
|
ClipItemsExceptCaret(children, aBuilder, aClipFrame, aExtraClip, aCache);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ClipListsExceptCaret(nsDisplayListCollection* aLists,
|
|
nsDisplayListBuilder* aBuilder,
|
|
nsIFrame* aClipFrame,
|
|
const DisplayItemClipChain* aExtraClip) {
|
|
nsTHashMap<nsPtrHashKey<const DisplayItemClipChain>,
|
|
const DisplayItemClipChain*>
|
|
cache;
|
|
ClipItemsExceptCaret(aLists->BorderBackground(), aBuilder, aClipFrame,
|
|
aExtraClip, cache);
|
|
ClipItemsExceptCaret(aLists->BlockBorderBackgrounds(), aBuilder, aClipFrame,
|
|
aExtraClip, cache);
|
|
ClipItemsExceptCaret(aLists->Floats(), aBuilder, aClipFrame, aExtraClip,
|
|
cache);
|
|
ClipItemsExceptCaret(aLists->PositionedDescendants(), aBuilder, aClipFrame,
|
|
aExtraClip, cache);
|
|
ClipItemsExceptCaret(aLists->Outlines(), aBuilder, aClipFrame, aExtraClip,
|
|
cache);
|
|
ClipItemsExceptCaret(aLists->Content(), aBuilder, aClipFrame, aExtraClip,
|
|
cache);
|
|
}
|
|
|
|
// This is similar to a "save-restore" RAII class for
|
|
// DisplayListBuilder::ContainsBlendMode(), with a slight enhancement.
|
|
// If this class is put on the stack and then unwound, the DL builder's
|
|
// ContainsBlendMode flag will be effectively the same as if this class wasn't
|
|
// put on the stack. However, if the CaptureContainsBlendMode method is called,
|
|
// there will be a difference - the blend mode in the descendant display lists
|
|
// will be "captured" and extracted.
|
|
// The main goal here is to allow conditionally capturing the flag that
|
|
// indicates whether or not a blend mode was encountered in the descendant part
|
|
// of the display list.
|
|
class MOZ_RAII AutoContainsBlendModeCapturer {
|
|
nsDisplayListBuilder& mBuilder;
|
|
bool mSavedContainsBlendMode;
|
|
|
|
public:
|
|
explicit AutoContainsBlendModeCapturer(nsDisplayListBuilder& aBuilder)
|
|
: mBuilder(aBuilder),
|
|
mSavedContainsBlendMode(aBuilder.ContainsBlendMode()) {
|
|
mBuilder.SetContainsBlendMode(false);
|
|
}
|
|
|
|
bool CaptureContainsBlendMode() {
|
|
// "Capture" the flag by extracting and clearing the ContainsBlendMode flag
|
|
// on the builder.
|
|
bool capturedBlendMode = mBuilder.ContainsBlendMode();
|
|
mBuilder.SetContainsBlendMode(false);
|
|
return capturedBlendMode;
|
|
}
|
|
|
|
~AutoContainsBlendModeCapturer() {
|
|
// If CaptureContainsBlendMode() was called, the descendant blend mode was
|
|
// "captured" and so uncapturedContainsBlendMode will be false. If
|
|
// CaptureContainsBlendMode() wasn't called, then no capture occurred, and
|
|
// uncapturedContainsBlendMode may be true if there was a descendant blend
|
|
// mode. In that case, we set the flag on the DL builder so that we restore
|
|
// state to what it would have been without this RAII class on the stack.
|
|
bool uncapturedContainsBlendMode = mBuilder.ContainsBlendMode();
|
|
mBuilder.SetContainsBlendMode(mSavedContainsBlendMode ||
|
|
uncapturedContainsBlendMode);
|
|
}
|
|
};
|
|
|
|
// Finds the max z-index of the items in aList that meet the following
|
|
// conditions
|
|
// 1) have z-index auto or z-index >= 0.
|
|
// 2) aFrame is a proper ancestor of the item's frame.
|
|
// Returns -1 if there is no such item.
|
|
static int32_t MaxZIndexInListOfItemsContainedInFrame(nsDisplayList* aList,
|
|
nsIFrame* aFrame) {
|
|
int32_t maxZIndex = -1;
|
|
for (nsDisplayItem* item = aList->GetBottom(); item;
|
|
item = item->GetAbove()) {
|
|
nsIFrame* itemFrame = item->Frame();
|
|
// Perspective items return the scroll frame as their Frame(), so consider
|
|
// their TransformFrame() instead.
|
|
if (nsLayoutUtils::IsProperAncestorFrame(aFrame, itemFrame)) {
|
|
maxZIndex = std::max(maxZIndex, item->ZIndex());
|
|
}
|
|
}
|
|
return maxZIndex;
|
|
}
|
|
|
|
void ScrollFrameHelper::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists) {
|
|
SetAndNullOnExit<const nsIFrame> tmpBuilder(
|
|
mReferenceFrameDuringPainting, aBuilder->GetCurrentReferenceFrame());
|
|
if (aBuilder->IsForFrameVisibility()) {
|
|
NotifyApproximateFrameVisibilityUpdate(false);
|
|
}
|
|
|
|
mOuter->DisplayBorderBackgroundOutline(aBuilder, aLists);
|
|
|
|
if (aBuilder->IsPaintingToWindow()) {
|
|
if (IsMaybeScrollingActive() && !gfxVars::UseWebRender()) {
|
|
if (mScrollPosForLayerPixelAlignment == nsPoint(-1, -1)) {
|
|
mScrollPosForLayerPixelAlignment = GetScrollPosition();
|
|
}
|
|
} else {
|
|
mScrollPosForLayerPixelAlignment = nsPoint(-1, -1);
|
|
}
|
|
}
|
|
|
|
bool isRootContent =
|
|
mIsRoot && mOuter->PresContext()->IsRootContentDocumentCrossProcess();
|
|
|
|
nsRect effectiveScrollPort = mScrollPort;
|
|
if (isRootContent && mOuter->PresContext()->HasDynamicToolbar()) {
|
|
// Expand the scroll port to the size including the area covered by dynamic
|
|
// toolbar in the case where the dynamic toolbar is being used since
|
|
// position:fixed elements attached to this root scroller might be taller
|
|
// than its scroll port (e.g 100vh). Even if the dynamic toolbar covers the
|
|
// taller area, it doesn't mean the area is clipped by the toolbar because
|
|
// the dynamic toolbar is laid out outside of our topmost window and it
|
|
// transitions without changing our topmost window size.
|
|
effectiveScrollPort.SizeTo(nsLayoutUtils::ExpandHeightForDynamicToolbar(
|
|
mOuter->PresContext(), effectiveScrollPort.Size()));
|
|
}
|
|
|
|
// It's safe to get this value before the DecideScrollableLayer call below
|
|
// because that call cannot create a displayport for root scroll frames,
|
|
// and hence it cannot create an ignore scroll frame.
|
|
bool ignoringThisScrollFrame = aBuilder->GetIgnoreScrollFrame() == mOuter;
|
|
|
|
// Overflow clipping can never clip frames outside our subtree, so there
|
|
// is no need to worry about whether we are a moving frame that might clip
|
|
// non-moving frames.
|
|
// Not all our descendants will be clipped by overflow clipping, but all
|
|
// the ones that aren't clipped will be out of flow frames that have already
|
|
// had dirty rects saved for them by their parent frames calling
|
|
// MarkOutOfFlowChildrenForDisplayList, so it's safe to restrict our
|
|
// dirty rect here.
|
|
nsRect visibleRect = aBuilder->GetVisibleRect();
|
|
nsRect dirtyRect = aBuilder->GetDirtyRect();
|
|
if (!ignoringThisScrollFrame) {
|
|
visibleRect = visibleRect.Intersect(effectiveScrollPort);
|
|
dirtyRect = dirtyRect.Intersect(effectiveScrollPort);
|
|
}
|
|
|
|
bool dirtyRectHasBeenOverriden = false;
|
|
Unused << DecideScrollableLayer(aBuilder, &visibleRect, &dirtyRect,
|
|
/* aSetBase = */ !mIsRoot,
|
|
&dirtyRectHasBeenOverriden);
|
|
|
|
if (aBuilder->IsForFrameVisibility()) {
|
|
// We expand the dirty rect to catch frames just outside of the scroll port.
|
|
// We use the dirty rect instead of the whole scroll port to prevent
|
|
// too much expansion in the presence of very large (bigger than the
|
|
// viewport) scroll ports.
|
|
dirtyRect = ExpandRectToNearlyVisible(dirtyRect);
|
|
visibleRect = dirtyRect;
|
|
}
|
|
|
|
// We put non-overlay scrollbars in their own layers when this is the root
|
|
// scroll frame and we are a toplevel content document. In this situation,
|
|
// the scrollbar(s) would normally be assigned their own layer anyway, since
|
|
// they're not scrolled with the rest of the document. But when both
|
|
// scrollbars are visible, the layer's visible rectangle would be the size
|
|
// of the viewport, so most layer implementations would create a layer buffer
|
|
// that's much larger than necessary. Creating independent layers for each
|
|
// scrollbar works around the problem.
|
|
bool createLayersForScrollbars =
|
|
mIsRoot && mOuter->PresContext()->IsRootContentDocument();
|
|
|
|
nsIScrollableFrame* sf = do_QueryFrame(mOuter);
|
|
MOZ_ASSERT(sf);
|
|
|
|
if (ignoringThisScrollFrame) {
|
|
// Root scrollframes have FrameMetrics and clipping on their container
|
|
// layers, so don't apply clipping again.
|
|
mAddClipRectToLayer = false;
|
|
|
|
// If we are a root scroll frame that has a display port we want to add
|
|
// scrollbars, they will be children of the scrollable layer, but they get
|
|
// adjusted by the APZC automatically.
|
|
bool addScrollBars =
|
|
mIsRoot && mWillBuildScrollableLayer && aBuilder->IsPaintingToWindow();
|
|
|
|
nsDisplayListCollection set(aBuilder);
|
|
|
|
if (addScrollBars) {
|
|
// Add classic scrollbars.
|
|
AppendScrollPartsTo(aBuilder, set, createLayersForScrollbars, false);
|
|
}
|
|
|
|
{
|
|
nsDisplayListBuilder::AutoBuildingDisplayList building(
|
|
aBuilder, mOuter, visibleRect, dirtyRect);
|
|
|
|
// Don't clip the scrolled child, and don't paint scrollbars/scrollcorner.
|
|
// The scrolled frame shouldn't have its own background/border, so we
|
|
// can just pass aLists directly.
|
|
mOuter->BuildDisplayListForChild(aBuilder, mScrolledFrame, set);
|
|
}
|
|
|
|
if (nsDisplayWrapList* topLayerWrapList =
|
|
MaybeCreateTopLayerItems(aBuilder, nullptr)) {
|
|
set.PositionedDescendants()->AppendToTop(topLayerWrapList);
|
|
}
|
|
|
|
if (addScrollBars) {
|
|
// Add overlay scrollbars.
|
|
AppendScrollPartsTo(aBuilder, set, createLayersForScrollbars, true);
|
|
}
|
|
|
|
set.MoveTo(aLists);
|
|
return;
|
|
}
|
|
|
|
// Root scrollframes have FrameMetrics and clipping on their container
|
|
// layers, so don't apply clipping again.
|
|
mAddClipRectToLayer =
|
|
!(mIsRoot && mOuter->PresShell()->UsesMobileViewportSizing());
|
|
|
|
// Whether we might want to build a scrollable layer for this scroll frame
|
|
// at some point in the future. This controls whether we add the information
|
|
// to the layer tree (a scroll info layer if necessary, and add the right
|
|
// area to the dispatch to content layer event regions) necessary to activate
|
|
// a scroll frame so it creates a scrollable layer.
|
|
bool couldBuildLayer = false;
|
|
if (aBuilder->IsPaintingToWindow()) {
|
|
if (mWillBuildScrollableLayer) {
|
|
couldBuildLayer = true;
|
|
} else {
|
|
couldBuildLayer = mOuter->StyleVisibility()->IsVisible() &&
|
|
nsLayoutUtils::AsyncPanZoomEnabled(mOuter) &&
|
|
WantAsyncScroll();
|
|
}
|
|
}
|
|
|
|
// Now display the scrollbars and scrollcorner. These parts are drawn
|
|
// in the border-background layer, on top of our own background and
|
|
// borders and underneath borders and backgrounds of later elements
|
|
// in the tree.
|
|
// Note that this does not apply for overlay scrollbars; those are drawn
|
|
// in the positioned-elements layer on top of everything else by the call
|
|
// to AppendScrollPartsTo(..., true) further down.
|
|
AppendScrollPartsTo(aBuilder, aLists, createLayersForScrollbars, false);
|
|
|
|
const nsStyleDisplay* disp = mOuter->StyleDisplay();
|
|
if (aBuilder->IsForPainting() &&
|
|
disp->mWillChange.bits & StyleWillChangeBits::SCROLL) {
|
|
aBuilder->AddToWillChangeBudget(mOuter, GetVisualViewportSize());
|
|
}
|
|
|
|
mScrollParentID = aBuilder->GetCurrentScrollParentId();
|
|
|
|
Maybe<nsRect> contentBoxClip;
|
|
Maybe<const DisplayItemClipChain*> extraContentBoxClipForNonCaretContent;
|
|
if (MOZ_UNLIKELY(
|
|
disp->mOverflowClipBoxBlock == StyleOverflowClipBox::ContentBox ||
|
|
disp->mOverflowClipBoxInline == StyleOverflowClipBox::ContentBox)) {
|
|
WritingMode wm = mScrolledFrame->GetWritingMode();
|
|
bool cbH = (wm.IsVertical() ? disp->mOverflowClipBoxBlock
|
|
: disp->mOverflowClipBoxInline) ==
|
|
StyleOverflowClipBox::ContentBox;
|
|
bool cbV = (wm.IsVertical() ? disp->mOverflowClipBoxInline
|
|
: disp->mOverflowClipBoxBlock) ==
|
|
StyleOverflowClipBox::ContentBox;
|
|
// We only clip if there is *scrollable* overflow, to avoid clipping
|
|
// *ink* overflow unnecessarily.
|
|
nsRect clipRect = effectiveScrollPort + aBuilder->ToReferenceFrame(mOuter);
|
|
nsMargin padding = mOuter->GetUsedPadding();
|
|
if (!cbH) {
|
|
padding.left = padding.right = nscoord(0);
|
|
}
|
|
if (!cbV) {
|
|
padding.top = padding.bottom = nscoord(0);
|
|
}
|
|
clipRect.Deflate(padding);
|
|
|
|
nsRect so = mScrolledFrame->ScrollableOverflowRect();
|
|
if ((cbH && (clipRect.width != so.width || so.x < 0)) ||
|
|
(cbV && (clipRect.height != so.height || so.y < 0))) {
|
|
// The non-inflated clip needs to be set on all non-caret items.
|
|
// We prepare an extra DisplayItemClipChain here that will be intersected
|
|
// with those items after they've been created.
|
|
const ActiveScrolledRoot* asr = aBuilder->CurrentActiveScrolledRoot();
|
|
|
|
DisplayItemClip newClip;
|
|
newClip.SetTo(clipRect);
|
|
|
|
const DisplayItemClipChain* extraClip =
|
|
aBuilder->AllocateDisplayItemClipChain(newClip, asr, nullptr);
|
|
|
|
extraContentBoxClipForNonCaretContent = Some(extraClip);
|
|
|
|
nsIFrame* caretFrame = aBuilder->GetCaretFrame();
|
|
// Avoid clipping it in a zero-height line box (heuristic only).
|
|
if (caretFrame && caretFrame->GetRect().height != 0) {
|
|
nsRect caretRect = aBuilder->GetCaretRect();
|
|
// Allow the caret to stick out of the content box clip by half the
|
|
// caret height on the top, and its full width on the right.
|
|
nsRect inflatedClip = clipRect;
|
|
inflatedClip.Inflate(
|
|
nsMargin(caretRect.height / 2, caretRect.width, 0, 0));
|
|
contentBoxClip = Some(inflatedClip);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsDisplayListCollection set(aBuilder);
|
|
AutoContainsBlendModeCapturer blendCapture(*aBuilder);
|
|
|
|
bool willBuildAsyncZoomContainer =
|
|
mWillBuildScrollableLayer && aBuilder->ShouldBuildAsyncZoomContainer() &&
|
|
isRootContent;
|
|
|
|
nsRect scrollPortClip =
|
|
effectiveScrollPort + aBuilder->ToReferenceFrame(mOuter);
|
|
nsRect clipRect = scrollPortClip;
|
|
// Our override of GetBorderRadii ensures we never have a radius at
|
|
// the corners where we have a scrollbar.
|
|
nscoord radii[8];
|
|
bool haveRadii = mOuter->GetPaddingBoxBorderRadii(radii);
|
|
if (mIsRoot) {
|
|
clipRect.SizeTo(nsLayoutUtils::CalculateCompositionSizeForFrame(mOuter));
|
|
// The composition size is essentially in visual coordinates.
|
|
// If we are hit-testing in layout coordinates, transform the clip rect
|
|
// to layout coordinates to match.
|
|
if (aBuilder->IsRelativeToLayoutViewport() &&
|
|
mOuter->PresContext()->IsRootContentDocument()) {
|
|
clipRect = ViewportUtils::VisualToLayout(clipRect, mOuter->PresShell());
|
|
}
|
|
}
|
|
|
|
{
|
|
// Note that setting the current scroll parent id here means that positioned
|
|
// children of this scroll info layer will pick up the scroll info layer as
|
|
// their scroll handoff parent. This is intentional because that is what
|
|
// happens for positioned children of scroll layers, and we want to maintain
|
|
// consistent behaviour between scroll layers and scroll info layers.
|
|
nsDisplayListBuilder::AutoCurrentScrollParentIdSetter idSetter(
|
|
aBuilder,
|
|
couldBuildLayer && mScrolledFrame->GetContent()
|
|
? nsLayoutUtils::FindOrCreateIDFor(mScrolledFrame->GetContent())
|
|
: aBuilder->GetCurrentScrollParentId());
|
|
|
|
DisplayListClipState::AutoSaveRestore clipState(aBuilder);
|
|
// If we're building an async zoom container, clip the contents inside
|
|
// to the layout viewport (scrollPortClip). The composition bounds clip
|
|
// (clipRect) will be applied to the zoom container itself below.
|
|
nsRect clipRectForContents =
|
|
willBuildAsyncZoomContainer ? scrollPortClip : clipRect;
|
|
if (mClipAllDescendants) {
|
|
clipState.ClipContentDescendants(clipRectForContents,
|
|
haveRadii ? radii : nullptr);
|
|
} else {
|
|
clipState.ClipContainingBlockDescendants(clipRectForContents,
|
|
haveRadii ? radii : nullptr);
|
|
}
|
|
|
|
Maybe<DisplayListClipState::AutoSaveRestore> contentBoxClipState;
|
|
;
|
|
if (contentBoxClip) {
|
|
contentBoxClipState.emplace(aBuilder);
|
|
if (mClipAllDescendants) {
|
|
contentBoxClipState->ClipContentDescendants(*contentBoxClip);
|
|
} else {
|
|
contentBoxClipState->ClipContainingBlockDescendants(*contentBoxClip);
|
|
}
|
|
}
|
|
|
|
nsDisplayListBuilder::AutoCurrentActiveScrolledRootSetter asrSetter(
|
|
aBuilder);
|
|
if (mWillBuildScrollableLayer && aBuilder->IsPaintingToWindow()) {
|
|
asrSetter.EnterScrollFrame(sf);
|
|
}
|
|
|
|
if (mWillBuildScrollableLayer && aBuilder->BuildCompositorHitTestInfo()) {
|
|
// Create a hit test info item for the scrolled content that's not
|
|
// clipped to the displayport. This ensures that within the bounds
|
|
// of the scroll frame, the scrolled content is always hit, even
|
|
// if we are checkerboarding.
|
|
CompositorHitTestInfo info =
|
|
mScrolledFrame->GetCompositorHitTestInfo(aBuilder);
|
|
|
|
if (info != CompositorHitTestInvisibleToHit) {
|
|
auto* hitInfo =
|
|
MakeDisplayItemWithIndex<nsDisplayCompositorHitTestInfo>(
|
|
aBuilder, mScrolledFrame, 1);
|
|
if (hitInfo) {
|
|
aBuilder->SetCompositorHitTestInfo(info);
|
|
set.BorderBackground()->AppendToTop(hitInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
// Clip our contents to the unsnapped scrolled rect. This makes sure
|
|
// that we don't have display items over the subpixel seam at the edge
|
|
// of the scrolled area.
|
|
DisplayListClipState::AutoSaveRestore scrolledRectClipState(aBuilder);
|
|
nsRect scrolledRectClip =
|
|
GetUnsnappedScrolledRectInternal(
|
|
mScrolledFrame->ScrollableOverflowRect(), mScrollPort.Size()) +
|
|
mScrolledFrame->GetPosition();
|
|
bool clippedToDisplayPort = false;
|
|
if (mWillBuildScrollableLayer && aBuilder->IsPaintingToWindow()) {
|
|
// Clip the contents to the display port.
|
|
// The dirty rect already acts kind of like a clip, in that
|
|
// FrameLayerBuilder intersects item bounds and opaque regions with
|
|
// it, but it doesn't have the consistent snapping behavior of a
|
|
// true clip.
|
|
// For a case where this makes a difference, imagine the following
|
|
// scenario: The display port has an edge that falls on a fractional
|
|
// layer pixel, and there's an opaque display item that covers the
|
|
// whole display port up until that fractional edge, and there is a
|
|
// transparent display item that overlaps the edge. We want to prevent
|
|
// this transparent item from enlarging the scrolled layer's visible
|
|
// region beyond its opaque region. The dirty rect doesn't do that -
|
|
// it gets rounded out, whereas a true clip gets rounded to nearest
|
|
// pixels.
|
|
// If there is no display port, we don't need this because the clip
|
|
// from the scroll port is still applied.
|
|
scrolledRectClip = scrolledRectClip.Intersect(visibleRect);
|
|
clippedToDisplayPort = scrolledRectClip.IsEqualEdges(visibleRect);
|
|
}
|
|
scrolledRectClipState.ClipContainingBlockDescendants(
|
|
scrolledRectClip + aBuilder->ToReferenceFrame(mOuter));
|
|
if (clippedToDisplayPort) {
|
|
// We have to do this after the ClipContainingBlockDescendants call
|
|
// above, otherwise that call will clobber the flag set by this call
|
|
// to SetClippedToDisplayPort.
|
|
scrolledRectClipState.SetClippedToDisplayPort();
|
|
}
|
|
|
|
nsRect visibleRectForChildren = visibleRect;
|
|
nsRect dirtyRectForChildren = dirtyRect;
|
|
|
|
// If we are entering the RCD-RSF, we are crossing the async zoom
|
|
// container boundary, and need to convert from visual to layout
|
|
// coordinates.
|
|
if (willBuildAsyncZoomContainer && aBuilder->IsForEventDelivery()) {
|
|
MOZ_ASSERT(ViewportUtils::IsZoomedContentRoot(mScrolledFrame));
|
|
visibleRectForChildren = ViewportUtils::VisualToLayout(
|
|
visibleRectForChildren, mOuter->PresShell());
|
|
dirtyRectForChildren = ViewportUtils::VisualToLayout(
|
|
dirtyRectForChildren, mOuter->PresShell());
|
|
}
|
|
|
|
nsDisplayListBuilder::AutoBuildingDisplayList building(
|
|
aBuilder, mOuter, visibleRectForChildren, dirtyRectForChildren);
|
|
|
|
mOuter->BuildDisplayListForChild(aBuilder, mScrolledFrame, set);
|
|
|
|
if (dirtyRectHasBeenOverriden &&
|
|
StaticPrefs::layout_display_list_show_rebuild_area()) {
|
|
nsDisplaySolidColor* color = MakeDisplayItem<nsDisplaySolidColor>(
|
|
aBuilder, mOuter,
|
|
dirtyRect + aBuilder->GetCurrentFrameOffsetToReferenceFrame(),
|
|
NS_RGBA(0, 0, 255, 64), false);
|
|
if (color) {
|
|
color->SetOverrideZIndex(INT32_MAX);
|
|
set.PositionedDescendants()->AppendToTop(color);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (extraContentBoxClipForNonCaretContent) {
|
|
// The items were built while the inflated content box clip was in
|
|
// effect, so that the caret wasn't clipped unnecessarily. We apply
|
|
// the non-inflated clip to the non-caret items now, by intersecting
|
|
// it with their existing clip.
|
|
ClipListsExceptCaret(&set, aBuilder, mScrolledFrame,
|
|
*extraContentBoxClipForNonCaretContent);
|
|
}
|
|
|
|
if (aBuilder->IsPaintingToWindow()) {
|
|
mIsParentToActiveScrollFrames =
|
|
ShouldActivateAllScrollFrames()
|
|
? idSetter.GetContainsNonMinimalDisplayPort()
|
|
: idSetter.ShouldForceLayerForScrollParent();
|
|
}
|
|
if (idSetter.ShouldForceLayerForScrollParent()) {
|
|
// Note that forcing layerization of scroll parents follows the scroll
|
|
// handoff chain which is subject to the out-of-flow-frames caveat noted
|
|
// above (where the idSetter variable is created).
|
|
MOZ_ASSERT(couldBuildLayer && mScrolledFrame->GetContent() &&
|
|
aBuilder->IsPaintingToWindow());
|
|
if (!mWillBuildScrollableLayer) {
|
|
// Set a displayport so next paint we don't have to force layerization
|
|
// after the fact. It's ok to pass DoNotRepaint here, since we've
|
|
// already painted the change and we're just optimizing it to be
|
|
// detected earlier. We also won't confuse RetainedDisplayLists
|
|
// with the silent change, since we explicitly request partial updates
|
|
// to be disabled on the next paint.
|
|
DisplayPortUtils::SetDisplayPortMargins(
|
|
mOuter->GetContent(), mOuter->PresShell(),
|
|
DisplayPortMargins::Empty(mOuter->GetContent()),
|
|
DisplayPortUtils::ClearMinimalDisplayPortProperty::Yes, 0,
|
|
DisplayPortUtils::RepaintMode::DoNotRepaint);
|
|
// Call DecideScrollableLayer to recompute mWillBuildScrollableLayer
|
|
// and recompute the current animated geometry root if needed. It's
|
|
// too late to change the dirty rect so pass a copy.
|
|
nsRect copyOfDirtyRect = dirtyRect;
|
|
nsRect copyOfVisibleRect = visibleRect;
|
|
Unused << DecideScrollableLayer(aBuilder, ©OfVisibleRect,
|
|
©OfDirtyRect,
|
|
/* aSetBase = */ false, nullptr);
|
|
if (mWillBuildScrollableLayer) {
|
|
asrSetter.InsertScrollFrame(sf);
|
|
aBuilder->SetDisablePartialUpdates(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create any required items for the 'top layer' and check if they'll be
|
|
// opaque over the entire area of the viewport. If they are, then we can
|
|
// skip building display items for the rest of the page.
|
|
bool topLayerIsOpaque = false;
|
|
if (nsDisplayWrapList* topLayerWrapList =
|
|
MaybeCreateTopLayerItems(aBuilder, &topLayerIsOpaque)) {
|
|
// If the top layer content is opaque, and we're the root content document,
|
|
// we can drop the display items behind it. We only support doing this for
|
|
// the root document, since the top layer content might have fixed position
|
|
// items that have a scrolltarget referencing the APZ data for the document.
|
|
// APZ builds this data implicitly for the root document, but subdocuments
|
|
// need their display items to generate it, so we can't cull those.
|
|
if (topLayerIsOpaque && mOuter->PresContext()->IsRootContentDocument()) {
|
|
set.DeleteAll(aBuilder);
|
|
}
|
|
set.PositionedDescendants()->AppendToTop(topLayerWrapList);
|
|
}
|
|
|
|
if (willBuildAsyncZoomContainer) {
|
|
MOZ_ASSERT(mClipAllDescendants);
|
|
|
|
// Wrap all our scrolled contents in an nsDisplayAsyncZoom. This will be
|
|
// the layer that gets scaled for APZ zooming. It does not have the
|
|
// scrolled ASR, but it does have the composition bounds clip applied to
|
|
// it. The children have the layout viewport clip applied to them (above).
|
|
// Effectively we are double clipping to the viewport, at potentially
|
|
// different async scales.
|
|
|
|
nsDisplayList resultList;
|
|
set.SerializeWithCorrectZOrder(&resultList, mOuter->GetContent());
|
|
|
|
if (blendCapture.CaptureContainsBlendMode()) {
|
|
// The async zoom contents contain a mix-blend mode, so let's wrap all
|
|
// those contents into a blend container, and then wrap the blend
|
|
// container in the async zoom container. Otherwise the blend container
|
|
// ends up outside the zoom container which results in blend failure for
|
|
// WebRender.
|
|
nsDisplayItem* blendContainer =
|
|
nsDisplayBlendContainer::CreateForMixBlendMode(
|
|
aBuilder, mOuter, &resultList,
|
|
aBuilder->CurrentActiveScrolledRoot());
|
|
resultList.AppendToTop(blendContainer);
|
|
|
|
// Blend containers can be created or omitted during partial updates
|
|
// depending on the dirty rect. So we basically can't do partial updates
|
|
// if there's a blend container involved. There is equivalent code to this
|
|
// in the BuildDisplayListForStackingContext function as well, with a more
|
|
// detailed comment explaining things better.
|
|
if (aBuilder->IsRetainingDisplayList()) {
|
|
if (aBuilder->IsPartialUpdate()) {
|
|
aBuilder->SetPartialBuildFailed(true);
|
|
} else {
|
|
aBuilder->SetDisablePartialUpdates(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
mozilla::layers::FrameMetrics::ViewID viewID =
|
|
nsLayoutUtils::FindOrCreateIDFor(mScrolledFrame->GetContent());
|
|
|
|
DisplayListClipState::AutoSaveRestore clipState(aBuilder);
|
|
clipState.ClipContentDescendants(clipRect, haveRadii ? radii : nullptr);
|
|
|
|
set.Content()->AppendNewToTop<nsDisplayAsyncZoom>(
|
|
aBuilder, mOuter, &resultList, aBuilder->CurrentActiveScrolledRoot(),
|
|
viewID);
|
|
}
|
|
|
|
nsDisplayListCollection scrolledContent(aBuilder);
|
|
set.MoveTo(scrolledContent);
|
|
|
|
if (mWillBuildScrollableLayer && aBuilder->IsPaintingToWindow()) {
|
|
aBuilder->ForceLayerForScrollParent();
|
|
}
|
|
|
|
// We want to call SetContainsNonMinimalDisplayPort if
|
|
// mWillBuildScrollableLayer is true for any reason other than having a
|
|
// minimal display port.
|
|
if (aBuilder->IsPaintingToWindow()) {
|
|
if (DisplayPortUtils::HasNonMinimalDisplayPort(mOuter->GetContent()) ||
|
|
mZoomableByAPZ || nsContentUtils::HasScrollgrab(mOuter->GetContent())) {
|
|
aBuilder->SetContainsNonMinimalDisplayPort();
|
|
}
|
|
}
|
|
|
|
if (couldBuildLayer) {
|
|
CompositorHitTestInfo info(CompositorHitTestFlags::eVisibleToHitTest,
|
|
CompositorHitTestFlags::eInactiveScrollframe);
|
|
// If the scroll frame has non-default overscroll-behavior, instruct
|
|
// APZ to require a target confirmation before processing events that
|
|
// hit this scroll frame (that is, to drop the events if a
|
|
// confirmation does not arrive within the timeout period). Otherwise,
|
|
// APZ's fallback behaviour of scrolling the enclosing scroll frame
|
|
// would violate the specified overscroll-behavior.
|
|
auto overscroll = GetOverscrollBehaviorInfo();
|
|
if (overscroll.mBehaviorX != OverscrollBehavior::Auto ||
|
|
overscroll.mBehaviorY != OverscrollBehavior::Auto) {
|
|
info += CompositorHitTestFlags::eRequiresTargetConfirmation;
|
|
}
|
|
|
|
nsRect area = effectiveScrollPort + aBuilder->ToReferenceFrame(mOuter);
|
|
|
|
// Make sure that APZ will dispatch events back to content so we can
|
|
// create a displayport for this frame. We'll add the item later on.
|
|
if (!mWillBuildScrollableLayer && aBuilder->BuildCompositorHitTestInfo()) {
|
|
int32_t zIndex = MaxZIndexInListOfItemsContainedInFrame(
|
|
scrolledContent.PositionedDescendants(), mOuter);
|
|
if (aBuilder->IsPartialUpdate()) {
|
|
for (nsDisplayItemBase* item : mScrolledFrame->DisplayItems()) {
|
|
if (item->GetType() ==
|
|
DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO) {
|
|
auto* hitTestItem =
|
|
static_cast<nsDisplayCompositorHitTestInfo*>(item);
|
|
if (hitTestItem->GetHitTestInfo().Info().contains(
|
|
CompositorHitTestFlags::eInactiveScrollframe)) {
|
|
zIndex = std::max(zIndex, hitTestItem->ZIndex());
|
|
item->SetCantBeReused();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Make sure the z-index of the inactive item is at least zero.
|
|
// Otherwise, it will end up behind non-positioned items in the scrolled
|
|
// content.
|
|
zIndex = std::max(zIndex, 0);
|
|
nsDisplayCompositorHitTestInfo* hitInfo =
|
|
MakeDisplayItemWithIndex<nsDisplayCompositorHitTestInfo>(
|
|
aBuilder, mScrolledFrame, 1, area, info);
|
|
if (hitInfo) {
|
|
AppendInternalItemToTop(scrolledContent, hitInfo, Some(zIndex));
|
|
aBuilder->SetCompositorHitTestInfo(info);
|
|
}
|
|
}
|
|
|
|
if (aBuilder->ShouldBuildScrollInfoItemsForHoisting()) {
|
|
aBuilder->AppendNewScrollInfoItemForHoisting(
|
|
MakeDisplayItem<nsDisplayScrollInfoLayer>(aBuilder, mScrolledFrame,
|
|
mOuter, info, area));
|
|
}
|
|
}
|
|
|
|
// Now display overlay scrollbars and the resizer, if we have one.
|
|
AppendScrollPartsTo(aBuilder, scrolledContent, createLayersForScrollbars,
|
|
true);
|
|
|
|
scrolledContent.MoveTo(aLists);
|
|
}
|
|
|
|
nsDisplayWrapList* ScrollFrameHelper::MaybeCreateTopLayerItems(
|
|
nsDisplayListBuilder* aBuilder, bool* aIsOpaque) {
|
|
if (!mIsRoot) {
|
|
return nullptr;
|
|
}
|
|
|
|
ViewportFrame* viewport = do_QueryFrame(mOuter->GetParent());
|
|
if (!viewport) {
|
|
return nullptr;
|
|
}
|
|
|
|
return viewport->BuildDisplayListForTopLayer(aBuilder, aIsOpaque);
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::RestrictToRootDisplayPort(
|
|
const nsRect& aDisplayportBase) {
|
|
// This function clips aDisplayportBase so that it is no larger than the
|
|
// root frame's displayport (or the root composition bounds, if we can't
|
|
// obtain the root frame's displayport). This is useful for ensuring that
|
|
// the displayport of a tall scrollframe doesn't gobble up all the memory.
|
|
|
|
nsPresContext* pc = mOuter->PresContext();
|
|
const nsPresContext* rootPresContext =
|
|
pc->GetInProcessRootContentDocumentPresContext();
|
|
if (!rootPresContext) {
|
|
rootPresContext = pc->GetRootPresContext();
|
|
}
|
|
if (!rootPresContext) {
|
|
return aDisplayportBase;
|
|
}
|
|
const mozilla::PresShell* const rootPresShell = rootPresContext->PresShell();
|
|
nsIFrame* rootFrame = rootPresShell->GetRootScrollFrame();
|
|
if (!rootFrame) {
|
|
rootFrame = rootPresShell->GetRootFrame();
|
|
}
|
|
if (!rootFrame) {
|
|
return aDisplayportBase;
|
|
}
|
|
|
|
// Make sure we aren't trying to restrict to our own displayport, which is a
|
|
// circular dependency.
|
|
MOZ_ASSERT(!mIsRoot || rootPresContext != pc);
|
|
|
|
nsRect rootDisplayPort;
|
|
bool hasDisplayPort =
|
|
rootFrame->GetContent() && DisplayPortUtils::GetDisplayPort(
|
|
rootFrame->GetContent(), &rootDisplayPort);
|
|
if (hasDisplayPort) {
|
|
// The display port of the root frame already factors in it's callback
|
|
// transform, so subtract it out here, the GetCumulativeApzCallbackTransform
|
|
// call below will add it back.
|
|
MOZ_LOG(sDisplayportLog, LogLevel::Verbose,
|
|
("RestrictToRootDisplayPort: Existing root displayport is %s\n",
|
|
ToString(rootDisplayPort).c_str()));
|
|
if (nsIContent* content = rootFrame->GetContent()) {
|
|
if (void* property =
|
|
content->GetProperty(nsGkAtoms::apzCallbackTransform)) {
|
|
rootDisplayPort -=
|
|
CSSPoint::ToAppUnits(*static_cast<CSSPoint*>(property));
|
|
}
|
|
}
|
|
} else {
|
|
// If we don't have a display port on the root frame let's fall back to
|
|
// the root composition bounds instead.
|
|
nsRect rootCompBounds =
|
|
nsRect(nsPoint(0, 0),
|
|
nsLayoutUtils::CalculateCompositionSizeForFrame(rootFrame));
|
|
|
|
// If rootFrame is the RCD-RSF then
|
|
// CalculateCompositionSizeForFrame did not take the document's
|
|
// resolution into account, so we must.
|
|
if (rootPresContext->IsRootContentDocument() &&
|
|
rootFrame == rootPresShell->GetRootScrollFrame()) {
|
|
MOZ_LOG(
|
|
sDisplayportLog, LogLevel::Verbose,
|
|
("RestrictToRootDisplayPort: Removing resolution %f from root "
|
|
"composition bounds %s\n",
|
|
rootPresShell->GetResolution(), ToString(rootCompBounds).c_str()));
|
|
rootCompBounds =
|
|
rootCompBounds.RemoveResolution(rootPresShell->GetResolution());
|
|
}
|
|
|
|
rootDisplayPort = rootCompBounds;
|
|
}
|
|
MOZ_LOG(sDisplayportLog, LogLevel::Verbose,
|
|
("RestrictToRootDisplayPort: Intermediate root displayport %s\n",
|
|
ToString(rootDisplayPort).c_str()));
|
|
|
|
// We want to convert the root display port from the
|
|
// coordinate space of |rootFrame| to the coordinate space of
|
|
// |mOuter|. We do that with the TransformRect call below.
|
|
// However, since we care about the root display port
|
|
// relative to what the user is actually seeing, we also need to
|
|
// incorporate the APZ callback transforms into this. Most of the
|
|
// time those transforms are negligible, but in some cases (e.g.
|
|
// when a zoom is applied on an overflow:hidden document) it is
|
|
// not (see bug 1280013).
|
|
// XXX: Eventually we may want to create a modified version of
|
|
// TransformRect that includes the APZ callback transforms
|
|
// directly.
|
|
nsLayoutUtils::TransformRect(rootFrame, mOuter, rootDisplayPort);
|
|
MOZ_LOG(sDisplayportLog, LogLevel::Verbose,
|
|
("RestrictToRootDisplayPort: Transformed root displayport %s\n",
|
|
ToString(rootDisplayPort).c_str()));
|
|
rootDisplayPort += CSSPoint::ToAppUnits(
|
|
nsLayoutUtils::GetCumulativeApzCallbackTransform(mOuter));
|
|
MOZ_LOG(sDisplayportLog, LogLevel::Verbose,
|
|
("RestrictToRootDisplayPort: Final root displayport %s\n",
|
|
ToString(rootDisplayPort).c_str()));
|
|
|
|
// We want to limit aDisplayportBase to be no larger than
|
|
// rootDisplayPort on either axis, but we don't want to just
|
|
// blindly intersect the two, because rootDisplayPort might be
|
|
// offset from where aDisplayportBase is (see bug 1327095 comment
|
|
// 8). Instead, we translate rootDisplayPort so as to maximize the
|
|
// overlap with aDisplayportBase, and *then* do the intersection.
|
|
if (rootDisplayPort.x > aDisplayportBase.x &&
|
|
rootDisplayPort.XMost() > aDisplayportBase.XMost()) {
|
|
// rootDisplayPort is at a greater x-position for both left and
|
|
// right, so translate it such that the XMost() values are the
|
|
// same. This will line up the right edge of the two rects, and
|
|
// might mean that rootDisplayPort.x is smaller than
|
|
// aDisplayportBase.x. We can avoid that by taking the min of the
|
|
// x delta and XMost() delta, but it doesn't really matter
|
|
// because the intersection between the two rects below will end
|
|
// up the same.
|
|
rootDisplayPort.x -= (rootDisplayPort.XMost() - aDisplayportBase.XMost());
|
|
} else if (rootDisplayPort.x < aDisplayportBase.x &&
|
|
rootDisplayPort.XMost() < aDisplayportBase.XMost()) {
|
|
// Analaogous code for when the rootDisplayPort is at a smaller
|
|
// x-position.
|
|
rootDisplayPort.x = aDisplayportBase.x;
|
|
}
|
|
// Do the same for y-axis
|
|
if (rootDisplayPort.y > aDisplayportBase.y &&
|
|
rootDisplayPort.YMost() > aDisplayportBase.YMost()) {
|
|
rootDisplayPort.y -= (rootDisplayPort.YMost() - aDisplayportBase.YMost());
|
|
} else if (rootDisplayPort.y < aDisplayportBase.y &&
|
|
rootDisplayPort.YMost() < aDisplayportBase.YMost()) {
|
|
rootDisplayPort.y = aDisplayportBase.y;
|
|
}
|
|
MOZ_LOG(
|
|
sDisplayportLog, LogLevel::Verbose,
|
|
("RestrictToRootDisplayPort: Root displayport translated to %s to "
|
|
"better enclose %s\n",
|
|
ToString(rootDisplayPort).c_str(), ToString(aDisplayportBase).c_str()));
|
|
|
|
// Now we can do the intersection
|
|
return aDisplayportBase.Intersect(rootDisplayPort);
|
|
}
|
|
|
|
/* static */ bool ScrollFrameHelper::ShouldActivateAllScrollFrames() {
|
|
if (gfxVars::UseWebRender()) {
|
|
return (StaticPrefs::apz_wr_activate_all_scroll_frames() ||
|
|
(StaticPrefs::apz_wr_activate_all_scroll_frames_when_fission() &&
|
|
FissionAutostart()));
|
|
} else {
|
|
return (StaticPrefs::apz_nonwr_activate_all_scroll_frames() ||
|
|
(StaticPrefs::apz_nonwr_activate_all_scroll_frames_when_fission() &&
|
|
FissionAutostart()));
|
|
}
|
|
}
|
|
|
|
bool ScrollFrameHelper::DecideScrollableLayer(
|
|
nsDisplayListBuilder* aBuilder, nsRect* aVisibleRect, nsRect* aDirtyRect,
|
|
bool aSetBase, bool* aDirtyRectHasBeenOverriden) {
|
|
// Save and check if this changes so we can recompute the current agr.
|
|
bool oldWillBuildScrollableLayer = mWillBuildScrollableLayer;
|
|
|
|
nsIContent* content = mOuter->GetContent();
|
|
// For hit testing purposes with fission we want to create a
|
|
// minimal display port for every scroll frame that could be active. (We only
|
|
// do this when aSetBase is true because we only want to do this the first
|
|
// time this function is called for the same scroll frame.)
|
|
if (ShouldActivateAllScrollFrames() &&
|
|
!DisplayPortUtils::HasDisplayPort(content) &&
|
|
nsLayoutUtils::AsyncPanZoomEnabled(mOuter) && WantAsyncScroll() &&
|
|
aBuilder->IsPaintingToWindow() && aSetBase) {
|
|
// SetDisplayPortMargins calls TriggerDisplayPortExpiration which starts a
|
|
// display port expiry timer for display ports that do expire. However
|
|
// minimal display ports do not expire, so the display port has to be
|
|
// marked before the SetDisplayPortMargins call so the expiry timer
|
|
// doesn't get started.
|
|
content->SetProperty(nsGkAtoms::MinimalDisplayPort,
|
|
reinterpret_cast<void*>(true));
|
|
|
|
DisplayPortUtils::SetDisplayPortMargins(
|
|
content, mOuter->PresShell(), DisplayPortMargins::Empty(content),
|
|
DisplayPortUtils::ClearMinimalDisplayPortProperty::No, 0,
|
|
DisplayPortUtils::RepaintMode::DoNotRepaint);
|
|
}
|
|
|
|
bool usingDisplayPort = DisplayPortUtils::HasDisplayPort(content);
|
|
if (aBuilder->IsPaintingToWindow()) {
|
|
if (aSetBase) {
|
|
nsRect displayportBase = *aVisibleRect;
|
|
nsPresContext* pc = mOuter->PresContext();
|
|
|
|
bool isContentRootDoc = pc->IsRootContentDocumentCrossProcess();
|
|
bool isChromeRootDoc =
|
|
!pc->Document()->IsContentDocument() && !pc->GetParentPresContext();
|
|
|
|
if (mIsRoot && (isContentRootDoc || isChromeRootDoc)) {
|
|
displayportBase =
|
|
nsRect(nsPoint(0, 0),
|
|
nsLayoutUtils::CalculateCompositionSizeForFrame(mOuter));
|
|
} else {
|
|
// Make the displayport base equal to the visible rect restricted to
|
|
// the scrollport and the root composition bounds, relative to the
|
|
// scrollport.
|
|
displayportBase = aVisibleRect->Intersect(mScrollPort);
|
|
|
|
mozilla::layers::ScrollableLayerGuid::ViewID viewID =
|
|
mozilla::layers::ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
if (MOZ_LOG_TEST(sDisplayportLog, LogLevel::Verbose)) {
|
|
nsLayoutUtils::FindIDFor(mOuter->GetContent(), &viewID);
|
|
MOZ_LOG(
|
|
sDisplayportLog, LogLevel::Verbose,
|
|
("Scroll id %" PRIu64 " has visible rect %s, scroll port %s\n",
|
|
viewID, ToString(*aVisibleRect).c_str(),
|
|
ToString(mScrollPort).c_str()));
|
|
}
|
|
|
|
// Only restrict to the root displayport bounds if necessary,
|
|
// as the required coordinate transformation is expensive.
|
|
// And don't call RestrictToRootDisplayPort if we would be trying to
|
|
// restrict to our own display port, which doesn't make sense (ie if we
|
|
// are a root scroll frame in a process root prescontext).
|
|
if (usingDisplayPort && (!mIsRoot || pc->GetParentPresContext())) {
|
|
displayportBase = RestrictToRootDisplayPort(displayportBase);
|
|
MOZ_LOG(sDisplayportLog, LogLevel::Verbose,
|
|
("Scroll id %" PRIu64 " has restricted base %s\n", viewID,
|
|
ToString(displayportBase).c_str()));
|
|
}
|
|
displayportBase -= mScrollPort.TopLeft();
|
|
}
|
|
|
|
DisplayPortUtils::SetDisplayPortBase(mOuter->GetContent(),
|
|
displayportBase);
|
|
}
|
|
|
|
// If we don't have aSetBase == true then should have already
|
|
// been called with aSetBase == true which should have set a
|
|
// displayport base.
|
|
MOZ_ASSERT(content->GetProperty(nsGkAtoms::DisplayPortBase));
|
|
nsRect displayPort;
|
|
usingDisplayPort = DisplayPortUtils::GetDisplayPort(
|
|
content, &displayPort,
|
|
DisplayPortOptions().With(DisplayportRelativeTo::ScrollFrame));
|
|
|
|
if (usingDisplayPort) {
|
|
// Override the dirty rectangle if the displayport has been set.
|
|
*aVisibleRect = displayPort;
|
|
if (!aBuilder->IsPartialUpdate() || aBuilder->InInvalidSubtree() ||
|
|
mOuter->IsFrameModified()) {
|
|
*aDirtyRect = displayPort;
|
|
if (aDirtyRectHasBeenOverriden) {
|
|
*aDirtyRectHasBeenOverriden = true;
|
|
}
|
|
} else if (mOuter->HasOverrideDirtyRegion()) {
|
|
nsRect* rect = mOuter->GetProperty(
|
|
nsDisplayListBuilder::DisplayListBuildingDisplayPortRect());
|
|
if (rect) {
|
|
*aDirtyRect = *rect;
|
|
if (aDirtyRectHasBeenOverriden) {
|
|
*aDirtyRectHasBeenOverriden = true;
|
|
}
|
|
}
|
|
}
|
|
} else if (mIsRoot) {
|
|
// The displayPort getter takes care of adjusting for resolution. So if
|
|
// we have resolution but no displayPort then we need to adjust for
|
|
// resolution here.
|
|
PresShell* presShell = mOuter->PresShell();
|
|
*aVisibleRect =
|
|
aVisibleRect->RemoveResolution(presShell->GetResolution());
|
|
*aDirtyRect = aDirtyRect->RemoveResolution(presShell->GetResolution());
|
|
}
|
|
}
|
|
|
|
// Since making new layers is expensive, only create a scrollable layer
|
|
// for some scroll frames.
|
|
// When a displayport is being used, force building of a layer so that
|
|
// the compositor can find the scrollable layer for async scrolling.
|
|
// If the element is marked 'scrollgrab', also force building of a layer
|
|
// so that APZ can implement scroll grabbing.
|
|
mWillBuildScrollableLayer = usingDisplayPort ||
|
|
nsContentUtils::HasScrollgrab(content) ||
|
|
mZoomableByAPZ;
|
|
|
|
// The cached animated geometry root for the display builder is out of
|
|
// date if we just introduced a new animated geometry root.
|
|
if (oldWillBuildScrollableLayer != mWillBuildScrollableLayer) {
|
|
aBuilder->RecomputeCurrentAnimatedGeometryRoot();
|
|
}
|
|
|
|
return mWillBuildScrollableLayer;
|
|
}
|
|
|
|
void ScrollFrameHelper::NotifyApzTransaction() {
|
|
mAllowScrollOriginDowngrade = true;
|
|
mApzScrollPos = GetScrollPosition();
|
|
mApzAnimationRequested = IsLastScrollUpdateAnimating();
|
|
mScrollUpdates.Clear();
|
|
if (mIsRoot) {
|
|
mOuter->PresShell()->SetResolutionUpdated(false);
|
|
}
|
|
}
|
|
|
|
Maybe<ScrollMetadata> ScrollFrameHelper::ComputeScrollMetadata(
|
|
LayerManager* aLayerManager, const nsIFrame* aContainerReferenceFrame,
|
|
const Maybe<ContainerLayerParameters>& aParameters,
|
|
const DisplayItemClip* aClip) const {
|
|
if (!mWillBuildScrollableLayer) {
|
|
return Nothing();
|
|
}
|
|
|
|
Maybe<nsRect> parentLayerClip;
|
|
if (aClip && mAddClipRectToLayer) {
|
|
parentLayerClip = Some(aClip->GetClipRect());
|
|
}
|
|
|
|
bool isRootContent =
|
|
mIsRoot && mOuter->PresContext()->IsRootContentDocumentCrossProcess();
|
|
|
|
MOZ_ASSERT(mScrolledFrame->GetContent());
|
|
|
|
return Some(nsLayoutUtils::ComputeScrollMetadata(
|
|
mScrolledFrame, mOuter, mOuter->GetContent(), aContainerReferenceFrame,
|
|
aLayerManager, mScrollParentID, mScrollPort.Size(), parentLayerClip,
|
|
isRootContent, aParameters));
|
|
}
|
|
|
|
void ScrollFrameHelper::ClipLayerToDisplayPort(
|
|
Layer* aLayer, const DisplayItemClip* aClip,
|
|
const ContainerLayerParameters& aParameters) const {
|
|
// If APZ is not enabled, we still need the displayport to be clipped
|
|
// in the compositor.
|
|
if (!nsLayoutUtils::UsesAsyncScrolling(mOuter)) {
|
|
Maybe<nsRect> parentLayerClip;
|
|
if (aClip) {
|
|
parentLayerClip = Some(aClip->GetClipRect());
|
|
}
|
|
|
|
if (parentLayerClip) {
|
|
ParentLayerIntRect displayportClip =
|
|
ViewAs<ParentLayerPixel>(parentLayerClip->ScaleToNearestPixels(
|
|
aParameters.mXScale, aParameters.mYScale,
|
|
mScrolledFrame->PresContext()->AppUnitsPerDevPixel()));
|
|
|
|
ParentLayerIntRect layerClip;
|
|
if (const ParentLayerIntRect* origClip =
|
|
aLayer->GetClipRect().ptrOr(nullptr)) {
|
|
layerClip = displayportClip.Intersect(*origClip);
|
|
} else {
|
|
layerClip = displayportClip;
|
|
}
|
|
aLayer->SetClipRect(Some(layerClip));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsRectNearlyVisible(const nsRect& aRect) const {
|
|
// Use the right rect depending on if a display port is set.
|
|
nsRect displayPort;
|
|
bool usingDisplayport = DisplayPortUtils::GetDisplayPort(
|
|
mOuter->GetContent(), &displayPort,
|
|
DisplayPortOptions().With(DisplayportRelativeTo::ScrollFrame));
|
|
return aRect.Intersects(
|
|
ExpandRectToNearlyVisible(usingDisplayport ? displayPort : mScrollPort));
|
|
}
|
|
|
|
OverscrollBehaviorInfo ScrollFrameHelper::GetOverscrollBehaviorInfo() const {
|
|
nsIFrame* frame = GetFrameForStyle();
|
|
if (!frame) {
|
|
return {};
|
|
}
|
|
|
|
auto& disp = *frame->StyleDisplay();
|
|
return OverscrollBehaviorInfo::FromStyleConstants(disp.mOverscrollBehaviorX,
|
|
disp.mOverscrollBehaviorY);
|
|
}
|
|
|
|
ScrollStyles ScrollFrameHelper::GetScrollStylesFromFrame() const {
|
|
nsPresContext* presContext = mOuter->PresContext();
|
|
if (!presContext->IsDynamic() &&
|
|
!(mIsRoot && presContext->HasPaginatedScrolling())) {
|
|
return ScrollStyles(StyleOverflow::Hidden, StyleOverflow::Hidden);
|
|
}
|
|
|
|
if (!mIsRoot) {
|
|
return ScrollStyles(*mOuter->StyleDisplay(),
|
|
ScrollStyles::MapOverflowToValidScrollStyle);
|
|
}
|
|
|
|
ScrollStyles result = presContext->GetViewportScrollStylesOverride();
|
|
if (nsDocShell* ds = presContext->GetDocShell()) {
|
|
switch (ds->ScrollbarPreference()) {
|
|
case ScrollbarPreference::Auto:
|
|
break;
|
|
case ScrollbarPreference::Never:
|
|
result.mHorizontal = result.mVertical = StyleOverflow::Hidden;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::GetLayoutScrollRange() const {
|
|
return GetScrollRange(mScrollPort.width, mScrollPort.height);
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::GetScrollRange(nscoord aWidth,
|
|
nscoord aHeight) const {
|
|
nsRect range = GetScrolledRect();
|
|
range.width = std::max(range.width - aWidth, 0);
|
|
range.height = std::max(range.height - aHeight, 0);
|
|
return range;
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::GetVisualScrollRange() const {
|
|
nsSize visualViewportSize = GetVisualViewportSize();
|
|
return GetScrollRange(visualViewportSize.width, visualViewportSize.height);
|
|
}
|
|
|
|
nsSize ScrollFrameHelper::GetVisualViewportSize() const {
|
|
PresShell* presShell = mOuter->PresShell();
|
|
if (mIsRoot && presShell->IsVisualViewportSizeSet()) {
|
|
return presShell->GetVisualViewportSize();
|
|
}
|
|
return mScrollPort.Size();
|
|
}
|
|
|
|
nsPoint ScrollFrameHelper::GetVisualViewportOffset() const {
|
|
PresShell* presShell = mOuter->PresShell();
|
|
if (mIsRoot) {
|
|
if (auto pendingUpdate = presShell->GetPendingVisualScrollUpdate()) {
|
|
return pendingUpdate->mVisualScrollOffset;
|
|
}
|
|
if (presShell->IsVisualViewportOffsetSet()) {
|
|
return presShell->GetVisualViewportOffset();
|
|
}
|
|
}
|
|
return GetScrollPosition();
|
|
}
|
|
|
|
bool ScrollFrameHelper::SetVisualViewportOffset(const nsPoint& aOffset,
|
|
bool aRepaint) {
|
|
MOZ_ASSERT(mIsRoot);
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
AutoScrollbarRepaintSuppression repaintSuppression(this, weakFrame,
|
|
!aRepaint);
|
|
|
|
bool retVal = mOuter->PresShell()->SetVisualViewportOffset(
|
|
aOffset, GetScrollPosition());
|
|
if (!weakFrame.IsAlive()) {
|
|
return false;
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::GetVisualOptimalViewingRect() const {
|
|
PresShell* presShell = mOuter->PresShell();
|
|
nsRect rect = mScrollPort;
|
|
if (mIsRoot && presShell->IsVisualViewportSizeSet() &&
|
|
presShell->IsVisualViewportOffsetSet()) {
|
|
rect = nsRect(mScrollPort.TopLeft() - GetScrollPosition() +
|
|
presShell->GetVisualViewportOffset(),
|
|
presShell->GetVisualViewportSize());
|
|
}
|
|
// NOTE: We intentionally resolve scroll-padding percentages against the
|
|
// scrollport even when the visual viewport is set, see
|
|
// https://github.com/w3c/csswg-drafts/issues/4393.
|
|
rect.Deflate(GetScrollPadding());
|
|
return rect;
|
|
}
|
|
|
|
static void AdjustForWholeDelta(int32_t aDelta, nscoord* aCoord) {
|
|
if (aDelta < 0) {
|
|
*aCoord = nscoord_MIN;
|
|
} else if (aDelta > 0) {
|
|
*aCoord = nscoord_MAX;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate lower/upper scrollBy range in given direction.
|
|
* @param aDelta specifies scrollBy direction, if 0 then range will be 0 size
|
|
* @param aPos desired destination in AppUnits
|
|
* @param aNeg/PosTolerance defines relative range distance
|
|
* below and above of aPos point
|
|
* @param aMultiplier used for conversion of tolerance into appUnis
|
|
*/
|
|
static void CalcRangeForScrollBy(int32_t aDelta, nscoord aPos,
|
|
float aNegTolerance, float aPosTolerance,
|
|
nscoord aMultiplier, nscoord* aLower,
|
|
nscoord* aUpper) {
|
|
if (!aDelta) {
|
|
*aLower = *aUpper = aPos;
|
|
return;
|
|
}
|
|
*aLower = aPos - NSToCoordRound(aMultiplier *
|
|
(aDelta > 0 ? aNegTolerance : aPosTolerance));
|
|
*aUpper = aPos + NSToCoordRound(aMultiplier *
|
|
(aDelta > 0 ? aPosTolerance : aNegTolerance));
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollBy(nsIntPoint aDelta, ScrollUnit aUnit,
|
|
ScrollMode aMode, nsIntPoint* aOverflow,
|
|
ScrollOrigin aOrigin,
|
|
nsIScrollableFrame::ScrollMomentum aMomentum,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
// When a smooth scroll is being processed on a frame, mouse wheel and
|
|
// trackpad momentum scroll event updates must notcancel the SMOOTH or
|
|
// SMOOTH_MSD scroll animations, enabling Javascript that depends on them to
|
|
// be responsive without forcing the user to wait for the fling animations to
|
|
// completely stop.
|
|
switch (aMomentum) {
|
|
case nsIScrollableFrame::NOT_MOMENTUM:
|
|
mIgnoreMomentumScroll = false;
|
|
break;
|
|
case nsIScrollableFrame::SYNTHESIZED_MOMENTUM_EVENT:
|
|
if (mIgnoreMomentumScroll) {
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (mAsyncSmoothMSDScroll != nullptr) {
|
|
// When CSSOM-View scroll-behavior smooth scrolling is interrupted,
|
|
// the scroll is not completed to avoid non-smooth snapping to the
|
|
// prior smooth scroll's destination.
|
|
mDestination = GetScrollPosition();
|
|
}
|
|
|
|
nsSize deltaMultiplier;
|
|
float negativeTolerance;
|
|
float positiveTolerance;
|
|
if (aOrigin == ScrollOrigin::NotSpecified) {
|
|
aOrigin = ScrollOrigin::Other;
|
|
}
|
|
bool isGenericOrigin = (aOrigin == ScrollOrigin::Other);
|
|
|
|
bool askApzToDoTheScroll = false;
|
|
if ((aSnap != nsIScrollableFrame::ENABLE_SNAP || !NeedsScrollSnap()) &&
|
|
gfxPlatform::UseDesktopZoomingScrollbars() &&
|
|
nsLayoutUtils::AsyncPanZoomEnabled(mOuter) &&
|
|
!nsLayoutUtils::ShouldDisableApzForElement(mOuter->GetContent()) &&
|
|
(WantAsyncScroll() || mZoomableByAPZ)) {
|
|
askApzToDoTheScroll = true;
|
|
}
|
|
|
|
switch (aUnit) {
|
|
case ScrollUnit::DEVICE_PIXELS: {
|
|
nscoord appUnitsPerDevPixel =
|
|
mOuter->PresContext()->AppUnitsPerDevPixel();
|
|
deltaMultiplier = nsSize(appUnitsPerDevPixel, appUnitsPerDevPixel);
|
|
if (isGenericOrigin) {
|
|
aOrigin = ScrollOrigin::Pixels;
|
|
}
|
|
negativeTolerance = positiveTolerance = 0.5f;
|
|
break;
|
|
}
|
|
case ScrollUnit::LINES: {
|
|
deltaMultiplier = GetLineScrollAmount();
|
|
if (isGenericOrigin) {
|
|
aOrigin = ScrollOrigin::Lines;
|
|
}
|
|
negativeTolerance = positiveTolerance = 0.1f;
|
|
break;
|
|
}
|
|
case ScrollUnit::PAGES: {
|
|
deltaMultiplier = GetPageScrollAmount();
|
|
if (isGenericOrigin) {
|
|
aOrigin = ScrollOrigin::Pages;
|
|
}
|
|
negativeTolerance = 0.05f;
|
|
positiveTolerance = 0;
|
|
break;
|
|
}
|
|
case ScrollUnit::WHOLE: {
|
|
if (askApzToDoTheScroll) {
|
|
MOZ_ASSERT(aDelta.x >= -1 && aDelta.x <= 1 && aDelta.y >= -1 &&
|
|
aDelta.y <= 1);
|
|
deltaMultiplier = GetScrollRangeForUserInputEvents().Size();
|
|
break;
|
|
} else {
|
|
nsPoint pos = GetScrollPosition();
|
|
AdjustForWholeDelta(aDelta.x, &pos.x);
|
|
AdjustForWholeDelta(aDelta.y, &pos.y);
|
|
if (aSnap == nsIScrollableFrame::ENABLE_SNAP) {
|
|
GetSnapPointForDestination(aUnit, mDestination, pos);
|
|
}
|
|
ScrollTo(pos, aMode, ScrollOrigin::Other);
|
|
// 'this' might be destroyed here
|
|
if (aOverflow) {
|
|
*aOverflow = nsIntPoint(0, 0);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
default:
|
|
NS_ERROR("Invalid scroll mode");
|
|
return;
|
|
}
|
|
|
|
if (askApzToDoTheScroll) {
|
|
nsPoint delta(
|
|
NSCoordSaturatingNonnegativeMultiply(aDelta.x, deltaMultiplier.width),
|
|
NSCoordSaturatingNonnegativeMultiply(aDelta.y, deltaMultiplier.height));
|
|
|
|
AppendScrollUpdate(
|
|
ScrollPositionUpdate::NewPureRelativeScroll(aOrigin, aMode, delta));
|
|
|
|
nsIContent* content = mOuter->GetContent();
|
|
if (!DisplayPortUtils::HasNonMinimalNonZeroDisplayPort(content)) {
|
|
if (MOZ_LOG_TEST(sDisplayportLog, LogLevel::Debug)) {
|
|
mozilla::layers::ScrollableLayerGuid::ViewID viewID =
|
|
mozilla::layers::ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
nsLayoutUtils::FindIDFor(content, &viewID);
|
|
MOZ_LOG(
|
|
sDisplayportLog, LogLevel::Debug,
|
|
("ScrollBy setting displayport on scrollId=%" PRIu64 "\n", viewID));
|
|
}
|
|
|
|
DisplayPortUtils::CalculateAndSetDisplayPortMargins(
|
|
mOuter->GetScrollTargetFrame(),
|
|
DisplayPortUtils::RepaintMode::Repaint);
|
|
nsIFrame* frame = do_QueryFrame(mOuter->GetScrollTargetFrame());
|
|
DisplayPortUtils::SetZeroMarginDisplayPortOnAsyncScrollableAncestors(
|
|
frame);
|
|
}
|
|
|
|
mOuter->SchedulePaint();
|
|
return;
|
|
}
|
|
|
|
nsPoint newPos(NSCoordSaturatingAdd(mDestination.x,
|
|
NSCoordSaturatingNonnegativeMultiply(
|
|
aDelta.x, deltaMultiplier.width)),
|
|
NSCoordSaturatingAdd(mDestination.y,
|
|
NSCoordSaturatingNonnegativeMultiply(
|
|
aDelta.y, deltaMultiplier.height)));
|
|
|
|
if (aSnap == nsIScrollableFrame::ENABLE_SNAP) {
|
|
if (NeedsScrollSnap()) {
|
|
nscoord appUnitsPerDevPixel =
|
|
mOuter->PresContext()->AppUnitsPerDevPixel();
|
|
deltaMultiplier = nsSize(appUnitsPerDevPixel, appUnitsPerDevPixel);
|
|
negativeTolerance = 0.1f;
|
|
positiveTolerance = 0;
|
|
ScrollUnit snapUnit = aUnit;
|
|
if (aOrigin == ScrollOrigin::MouseWheel) {
|
|
// When using a clicky scroll wheel, snap point selection works the same
|
|
// as keyboard up/down/left/right navigation, but with varying amounts
|
|
// of scroll delta.
|
|
snapUnit = ScrollUnit::LINES;
|
|
}
|
|
GetSnapPointForDestination(snapUnit, mDestination, newPos);
|
|
}
|
|
}
|
|
|
|
// Calculate desired range values.
|
|
nscoord rangeLowerX, rangeUpperX, rangeLowerY, rangeUpperY;
|
|
CalcRangeForScrollBy(aDelta.x, newPos.x, negativeTolerance, positiveTolerance,
|
|
deltaMultiplier.width, &rangeLowerX, &rangeUpperX);
|
|
CalcRangeForScrollBy(aDelta.y, newPos.y, negativeTolerance, positiveTolerance,
|
|
deltaMultiplier.height, &rangeLowerY, &rangeUpperY);
|
|
nsRect range(rangeLowerX, rangeLowerY, rangeUpperX - rangeLowerX,
|
|
rangeUpperY - rangeLowerY);
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
ScrollToWithOrigin(newPos, aMode, aOrigin, &range);
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
|
|
if (aOverflow) {
|
|
nsPoint clampAmount = newPos - mDestination;
|
|
float appUnitsPerDevPixel = mOuter->PresContext()->AppUnitsPerDevPixel();
|
|
*aOverflow =
|
|
nsIntPoint(NSAppUnitsToIntPixels(clampAmount.x, appUnitsPerDevPixel),
|
|
NSAppUnitsToIntPixels(clampAmount.y, appUnitsPerDevPixel));
|
|
}
|
|
|
|
if (aUnit == ScrollUnit::DEVICE_PIXELS &&
|
|
!nsLayoutUtils::AsyncPanZoomEnabled(mOuter)) {
|
|
// When APZ is disabled, we must track the velocity
|
|
// on the main thread; otherwise, the APZC will manage this.
|
|
mVelocityQueue.Sample(GetScrollPosition());
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollByCSSPixels(
|
|
const CSSIntPoint& aDelta, ScrollMode aMode, ScrollOrigin aOrigin,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap) {
|
|
nsPoint current = GetScrollPosition();
|
|
// `current` value above might be a value which was aligned to in
|
|
// layer-pixels, so starting from such points will make the difference between
|
|
// the given position in script (e.g. scrollTo) and the aligned position
|
|
// larger, in the worst case the difference can be observed in CSS pixels.
|
|
// To avoid it, we use the current position in CSS pixels as the start
|
|
// position. Hopefully it exactly matches the position where it was given by
|
|
// the previous scrolling operation, but there may be some edge cases where
|
|
// the current position in CSS pixels differs from the given position, the
|
|
// cases should be fixed in bug 1556685.
|
|
CSSIntPoint currentCSSPixels = GetScrollPositionCSSPixels();
|
|
nsPoint pt = CSSPoint::ToAppUnits(currentCSSPixels + aDelta);
|
|
|
|
if (aSnap == nsIScrollableFrame::DEFAULT) {
|
|
aSnap = nsIScrollableFrame::ENABLE_SNAP;
|
|
}
|
|
|
|
if (aOrigin == ScrollOrigin::NotSpecified) {
|
|
aOrigin = ScrollOrigin::Other;
|
|
}
|
|
|
|
nscoord halfPixel = nsPresContext::CSSPixelsToAppUnits(0.5f);
|
|
nsRect range(pt.x - halfPixel, pt.y - halfPixel, 2 * halfPixel - 1,
|
|
2 * halfPixel - 1);
|
|
// XXX I don't think the following blocks are needed anymore, now that
|
|
// ScrollToImpl simply tries to scroll an integer number of layer
|
|
// pixels from the current position
|
|
if (aDelta.x == 0.0f) {
|
|
pt.x = current.x;
|
|
range.x = pt.x;
|
|
range.width = 0;
|
|
}
|
|
if (aDelta.y == 0.0f) {
|
|
pt.y = current.y;
|
|
range.y = pt.y;
|
|
range.height = 0;
|
|
}
|
|
ScrollToWithOrigin(pt, aMode, aOrigin, &range, aSnap);
|
|
// 'this' might be destroyed here
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollSnap(ScrollMode aMode) {
|
|
float flingSensitivity =
|
|
StaticPrefs::layout_css_scroll_snap_prediction_sensitivity();
|
|
int maxVelocity =
|
|
StaticPrefs::layout_css_scroll_snap_prediction_max_velocity();
|
|
maxVelocity = nsPresContext::CSSPixelsToAppUnits(maxVelocity);
|
|
int maxOffset = maxVelocity * flingSensitivity;
|
|
nsPoint velocity = mVelocityQueue.GetVelocity();
|
|
// Multiply each component individually to avoid integer multiply
|
|
nsPoint predictedOffset =
|
|
nsPoint(velocity.x * flingSensitivity, velocity.y * flingSensitivity);
|
|
predictedOffset.Clamp(maxOffset);
|
|
nsPoint pos = GetScrollPosition();
|
|
nsPoint destinationPos = pos + predictedOffset;
|
|
ScrollSnap(destinationPos, aMode);
|
|
}
|
|
|
|
void ScrollFrameHelper::ScrollSnap(const nsPoint& aDestination,
|
|
ScrollMode aMode) {
|
|
nsRect scrollRange = GetLayoutScrollRange();
|
|
nsPoint pos = GetScrollPosition();
|
|
nsPoint snapDestination = scrollRange.ClampPoint(aDestination);
|
|
if (GetSnapPointForDestination(ScrollUnit::DEVICE_PIXELS, pos,
|
|
snapDestination)) {
|
|
ScrollTo(snapDestination, aMode, ScrollOrigin::Other);
|
|
}
|
|
}
|
|
|
|
nsSize ScrollFrameHelper::GetLineScrollAmount() const {
|
|
RefPtr<nsFontMetrics> fm =
|
|
nsLayoutUtils::GetInflatedFontMetricsForFrame(mOuter);
|
|
NS_ASSERTION(fm, "FontMetrics is null, assuming fontHeight == 1 appunit");
|
|
int32_t appUnitsPerDevPixel = mOuter->PresContext()->AppUnitsPerDevPixel();
|
|
nscoord minScrollAmountInAppUnits =
|
|
std::max(1, StaticPrefs::mousewheel_min_line_scroll_amount()) *
|
|
appUnitsPerDevPixel;
|
|
nscoord horizontalAmount = fm ? fm->AveCharWidth() : 0;
|
|
nscoord verticalAmount = fm ? fm->MaxHeight() : 0;
|
|
return nsSize(std::max(horizontalAmount, minScrollAmountInAppUnits),
|
|
std::max(verticalAmount, minScrollAmountInAppUnits));
|
|
}
|
|
|
|
/**
|
|
* Compute the scrollport size excluding any fixed-pos and sticky-pos (that are
|
|
* stuck) headers and footers. A header or footer is an box that spans that
|
|
* entire width of the viewport and touches the top (or bottom, respectively) of
|
|
* the viewport. We also want to consider fixed/sticky elements that stack or
|
|
* overlap to effectively create a larger header or footer. Headers and footers
|
|
* that cover more than a third of the the viewport are ignored since they
|
|
* probably aren't true headers and footers and we don't want to restrict
|
|
* scrolling too much in such cases. This is a bit conservative --- some
|
|
* pages use elements as headers or footers that don't span the entire width
|
|
* of the viewport --- but it should be a good start.
|
|
*
|
|
* If aViewportFrame is non-null then the scroll frame is the root scroll
|
|
* frame and we should consider fixed-pos items.
|
|
*/
|
|
struct TopAndBottom {
|
|
TopAndBottom(nscoord aTop, nscoord aBottom) : top(aTop), bottom(aBottom) {}
|
|
|
|
nscoord top, bottom;
|
|
};
|
|
struct TopComparator {
|
|
bool Equals(const TopAndBottom& A, const TopAndBottom& B) const {
|
|
return A.top == B.top;
|
|
}
|
|
bool LessThan(const TopAndBottom& A, const TopAndBottom& B) const {
|
|
return A.top < B.top;
|
|
}
|
|
};
|
|
struct ReverseBottomComparator {
|
|
bool Equals(const TopAndBottom& A, const TopAndBottom& B) const {
|
|
return A.bottom == B.bottom;
|
|
}
|
|
bool LessThan(const TopAndBottom& A, const TopAndBottom& B) const {
|
|
return A.bottom > B.bottom;
|
|
}
|
|
};
|
|
|
|
static void AddToListIfHeaderFooter(nsIFrame* aFrame,
|
|
nsIFrame* aScrollPortFrame,
|
|
const nsRect& aScrollPort,
|
|
nsTArray<TopAndBottom>& aList) {
|
|
nsRect r = aFrame->GetRectRelativeToSelf();
|
|
r = nsLayoutUtils::TransformFrameRectToAncestor(aFrame, r, aScrollPortFrame);
|
|
r = r.Intersect(aScrollPort);
|
|
if ((r.width >= aScrollPort.width / 2 ||
|
|
r.width >= NSIntPixelsToAppUnits(800, AppUnitsPerCSSPixel())) &&
|
|
r.height <= aScrollPort.height / 3) {
|
|
aList.AppendElement(TopAndBottom(r.y, r.YMost()));
|
|
}
|
|
}
|
|
|
|
static nsSize GetScrollPortSizeExcludingHeadersAndFooters(
|
|
nsIFrame* aScrollFrame, nsIFrame* aViewportFrame,
|
|
const nsRect& aScrollPort) {
|
|
AutoTArray<TopAndBottom, 10> list;
|
|
if (aViewportFrame) {
|
|
nsFrameList fixedFrames =
|
|
aViewportFrame->GetChildList(nsIFrame::kFixedList);
|
|
for (nsFrameList::Enumerator iterator(fixedFrames); !iterator.AtEnd();
|
|
iterator.Next()) {
|
|
AddToListIfHeaderFooter(iterator.get(), aViewportFrame, aScrollPort,
|
|
list);
|
|
}
|
|
}
|
|
|
|
// Add sticky frames that are currently in "fixed" positions
|
|
StickyScrollContainer* ssc =
|
|
StickyScrollContainer::GetStickyScrollContainerForScrollFrame(
|
|
aScrollFrame);
|
|
if (ssc) {
|
|
const nsTArray<nsIFrame*>& stickyFrames = ssc->GetFrames();
|
|
for (nsIFrame* f : stickyFrames) {
|
|
// If it's acting like fixed position.
|
|
if (ssc->IsStuckInYDirection(f)) {
|
|
AddToListIfHeaderFooter(f, aScrollFrame, aScrollPort, list);
|
|
}
|
|
}
|
|
}
|
|
|
|
list.Sort(TopComparator());
|
|
nscoord headerBottom = 0;
|
|
for (uint32_t i = 0; i < list.Length(); ++i) {
|
|
if (list[i].top <= headerBottom) {
|
|
headerBottom = std::max(headerBottom, list[i].bottom);
|
|
}
|
|
}
|
|
|
|
list.Sort(ReverseBottomComparator());
|
|
nscoord footerTop = aScrollPort.height;
|
|
for (uint32_t i = 0; i < list.Length(); ++i) {
|
|
if (list[i].bottom >= footerTop) {
|
|
footerTop = std::min(footerTop, list[i].top);
|
|
}
|
|
}
|
|
|
|
headerBottom = std::min(aScrollPort.height / 3, headerBottom);
|
|
footerTop = std::max(aScrollPort.height - aScrollPort.height / 3, footerTop);
|
|
|
|
return nsSize(aScrollPort.width, footerTop - headerBottom);
|
|
}
|
|
|
|
nsSize ScrollFrameHelper::GetPageScrollAmount() const {
|
|
nsSize effectiveScrollPortSize;
|
|
|
|
if (GetVisualViewportSize() != mScrollPort.Size()) {
|
|
// We want to use the visual viewport size if one is set.
|
|
// The headers/footers adjustment is too complicated to do if there is a
|
|
// visual viewport that differs from the layout viewport, this is probably
|
|
// okay.
|
|
effectiveScrollPortSize = GetVisualViewportSize();
|
|
} else {
|
|
// Reduce effective scrollport height by the height of any
|
|
// fixed-pos/sticky-pos headers or footers
|
|
effectiveScrollPortSize = GetScrollPortSizeExcludingHeadersAndFooters(
|
|
mOuter, mIsRoot ? mOuter->PresShell()->GetRootFrame() : nullptr,
|
|
mScrollPort);
|
|
}
|
|
|
|
nsSize lineScrollAmount = GetLineScrollAmount();
|
|
|
|
// The page increment is the size of the page, minus the smaller of
|
|
// 10% of the size or 2 lines.
|
|
return nsSize(effectiveScrollPortSize.width -
|
|
std::min(effectiveScrollPortSize.width / 10,
|
|
2 * lineScrollAmount.width),
|
|
effectiveScrollPortSize.height -
|
|
std::min(effectiveScrollPortSize.height / 10,
|
|
2 * lineScrollAmount.height));
|
|
}
|
|
|
|
/**
|
|
* this code is resposible for restoring the scroll position back to some
|
|
* saved position. if the user has not moved the scroll position manually
|
|
* we keep scrolling down until we get to our original position. keep in
|
|
* mind that content could incrementally be coming in. we only want to stop
|
|
* when we reach our new position.
|
|
*/
|
|
void ScrollFrameHelper::ScrollToRestoredPosition() {
|
|
if (mRestorePos.y == -1 || mLastPos.x == -1 || mLastPos.y == -1) {
|
|
return;
|
|
}
|
|
// make sure our scroll position did not change for where we last put
|
|
// it. if it does then the user must have moved it, and we no longer
|
|
// need to restore.
|
|
//
|
|
// In the RTL case, we check whether the scroll position changed using the
|
|
// logical scroll position, but we scroll to the physical scroll position in
|
|
// all cases
|
|
|
|
// The layout offset we want to restore is the same as the visual offset
|
|
// (for now, may change in bug 1499210), but clamped to the layout scroll
|
|
// range (which can be a subset of the visual scroll range).
|
|
// Note that we can't do the clamping when initializing mRestorePos in
|
|
// RestoreState(), since the scrollable rect (which the clamping depends
|
|
// on) can change over the course of the restoration process.
|
|
nsPoint layoutRestorePos = GetLayoutScrollRange().ClampPoint(mRestorePos);
|
|
nsPoint visualRestorePos = GetVisualScrollRange().ClampPoint(mRestorePos);
|
|
|
|
// Continue restoring until both the layout and visual scroll positions
|
|
// reach the destination. (Note that the two can only be different for
|
|
// the root content document's root scroll frame, and when zoomed in).
|
|
// This is necessary to avoid situations where the two offsets get stuck
|
|
// at different values and nothing reconciles them (see bug 1519621 comment
|
|
// 8).
|
|
nsPoint logicalLayoutScrollPos = GetLogicalScrollPosition();
|
|
|
|
SCROLLRESTORE_LOG(
|
|
"%p: ScrollToRestoredPosition (mRestorePos=%s, mLastPos=%s, "
|
|
"layoutRestorePos=%s, visualRestorePos=%s, "
|
|
"logicalLayoutScrollPos=%s, "
|
|
"GetLogicalVisualViewportOffset()=%s)\n",
|
|
this, ToString(mRestorePos).c_str(), ToString(mLastPos).c_str(),
|
|
ToString(layoutRestorePos).c_str(), ToString(visualRestorePos).c_str(),
|
|
ToString(logicalLayoutScrollPos).c_str(),
|
|
ToString(GetLogicalVisualViewportOffset()).c_str());
|
|
|
|
// if we didn't move, we still need to restore
|
|
if (GetLogicalVisualViewportOffset() == mLastPos ||
|
|
logicalLayoutScrollPos == mLastPos) {
|
|
// if our desired position is different to the scroll position, scroll.
|
|
// remember that we could be incrementally loading so we may enter
|
|
// and scroll many times.
|
|
if (mRestorePos != mLastPos /* GetLogicalVisualViewportOffset() */ ||
|
|
layoutRestorePos != logicalLayoutScrollPos) {
|
|
LoadingState state = GetPageLoadingState();
|
|
if (state == LoadingState::Stopped && !mOuter->IsSubtreeDirty()) {
|
|
return;
|
|
}
|
|
nsPoint visualScrollToPos = visualRestorePos;
|
|
nsPoint layoutScrollToPos = layoutRestorePos;
|
|
if (!IsPhysicalLTR()) {
|
|
// convert from logical to physical scroll position
|
|
visualScrollToPos.x -=
|
|
(GetVisualViewportSize().width - mScrolledFrame->GetRect().width);
|
|
layoutScrollToPos.x -=
|
|
(GetVisualViewportSize().width - mScrolledFrame->GetRect().width);
|
|
}
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
// It's very important to pass ScrollOrigin::Restore here, so
|
|
// ScrollToWithOrigin won't clear out mRestorePos.
|
|
ScrollToWithOrigin(layoutScrollToPos, ScrollMode::Instant,
|
|
ScrollOrigin::Restore, nullptr);
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
if (mIsRoot) {
|
|
mOuter->PresShell()->ScrollToVisual(
|
|
visualScrollToPos, FrameMetrics::eRestore, ScrollMode::Instant);
|
|
}
|
|
if (state == LoadingState::Loading || mOuter->IsSubtreeDirty()) {
|
|
// If we're trying to do a history scroll restore, then we want to
|
|
// keep trying this until we succeed, because the page can be loading
|
|
// incrementally. So re-get the scroll position for the next iteration,
|
|
// it might not be exactly equal to mRestorePos due to rounding and
|
|
// clamping.
|
|
mLastPos = GetLogicalVisualViewportOffset();
|
|
return;
|
|
}
|
|
}
|
|
// If we get here, either we reached the desired position (mLastPos ==
|
|
// mRestorePos) or we're not trying to do a history scroll restore, so
|
|
// we can stop after the scroll attempt above.
|
|
mRestorePos.y = -1;
|
|
mLastPos.x = -1;
|
|
mLastPos.y = -1;
|
|
} else {
|
|
// user moved the position, so we won't need to restore
|
|
mLastPos.x = -1;
|
|
mLastPos.y = -1;
|
|
}
|
|
}
|
|
|
|
auto ScrollFrameHelper::GetPageLoadingState() -> LoadingState {
|
|
bool loadCompleted = false, stopped = false;
|
|
nsCOMPtr<nsIDocShell> ds =
|
|
mOuter->GetContent()->GetComposedDoc()->GetDocShell();
|
|
if (ds) {
|
|
nsCOMPtr<nsIContentViewer> cv;
|
|
ds->GetContentViewer(getter_AddRefs(cv));
|
|
if (cv) {
|
|
loadCompleted = cv->GetLoadCompleted();
|
|
stopped = cv->GetIsStopped();
|
|
}
|
|
}
|
|
return loadCompleted
|
|
? (stopped ? LoadingState::Stopped : LoadingState::Loaded)
|
|
: LoadingState::Loading;
|
|
}
|
|
|
|
nsresult ScrollFrameHelper::FireScrollPortEvent() {
|
|
mAsyncScrollPortEvent.Forget();
|
|
|
|
// Keep this in sync with PostOverflowEvent().
|
|
nsSize scrollportSize = mScrollPort.Size();
|
|
nsSize childSize = GetScrolledRect().Size();
|
|
|
|
// TODO(emilio): why do we need the whole WillPaintObserver infrastructure and
|
|
// can't use AddScriptRunner & co? I guess it made sense when we used
|
|
// WillPaintObserver for scroll events too, or when this used to flush.
|
|
//
|
|
// Should we remove this?
|
|
|
|
bool newVerticalOverflow = childSize.height > scrollportSize.height;
|
|
bool vertChanged = mVerticalOverflow != newVerticalOverflow;
|
|
|
|
bool newHorizontalOverflow = childSize.width > scrollportSize.width;
|
|
bool horizChanged = mHorizontalOverflow != newHorizontalOverflow;
|
|
|
|
if (!vertChanged && !horizChanged) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// If both either overflowed or underflowed then we dispatch only one
|
|
// DOM event.
|
|
bool both = vertChanged && horizChanged &&
|
|
newVerticalOverflow == newHorizontalOverflow;
|
|
InternalScrollPortEvent::OrientType orient;
|
|
if (both) {
|
|
orient = InternalScrollPortEvent::eBoth;
|
|
mHorizontalOverflow = newHorizontalOverflow;
|
|
mVerticalOverflow = newVerticalOverflow;
|
|
} else if (vertChanged) {
|
|
orient = InternalScrollPortEvent::eVertical;
|
|
mVerticalOverflow = newVerticalOverflow;
|
|
if (horizChanged) {
|
|
// We need to dispatch a separate horizontal DOM event. Do that the next
|
|
// time around since dispatching the vertical DOM event might destroy
|
|
// the frame.
|
|
PostOverflowEvent();
|
|
}
|
|
} else {
|
|
orient = InternalScrollPortEvent::eHorizontal;
|
|
mHorizontalOverflow = newHorizontalOverflow;
|
|
}
|
|
|
|
InternalScrollPortEvent event(
|
|
true,
|
|
(orient == InternalScrollPortEvent::eHorizontal ? mHorizontalOverflow
|
|
: mVerticalOverflow)
|
|
? eScrollPortOverflow
|
|
: eScrollPortUnderflow,
|
|
nullptr);
|
|
event.mOrient = orient;
|
|
return EventDispatcher::Dispatch(mOuter->GetContent(), mOuter->PresContext(),
|
|
&event);
|
|
}
|
|
|
|
void ScrollFrameHelper::PostScrollEndEvent() {
|
|
if (mScrollEndEvent) {
|
|
return;
|
|
}
|
|
|
|
// The ScrollEndEvent constructor registers itself with the refresh driver.
|
|
mScrollEndEvent = new ScrollEndEvent(this);
|
|
}
|
|
|
|
void ScrollFrameHelper::FireScrollEndEvent() {
|
|
MOZ_ASSERT(mOuter->GetContent());
|
|
MOZ_ASSERT(mScrollEndEvent);
|
|
mScrollEndEvent->Revoke();
|
|
mScrollEndEvent = nullptr;
|
|
|
|
nsContentUtils::DispatchEventOnlyToChrome(
|
|
mOuter->GetContent()->OwnerDoc(), mOuter->GetContent(), u"scrollend"_ns,
|
|
CanBubble::eYes, Cancelable::eNo);
|
|
}
|
|
|
|
void ScrollFrameHelper::ReloadChildFrames() {
|
|
mScrolledFrame = nullptr;
|
|
mHScrollbarBox = nullptr;
|
|
mVScrollbarBox = nullptr;
|
|
mScrollCornerBox = nullptr;
|
|
mResizerBox = nullptr;
|
|
|
|
for (nsIFrame* frame : mOuter->PrincipalChildList()) {
|
|
nsIContent* content = frame->GetContent();
|
|
if (content == mOuter->GetContent()) {
|
|
NS_ASSERTION(!mScrolledFrame, "Already found the scrolled frame");
|
|
mScrolledFrame = frame;
|
|
} else {
|
|
nsAutoString value;
|
|
if (content->IsElement()) {
|
|
content->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::orient,
|
|
value);
|
|
}
|
|
if (!value.IsEmpty()) {
|
|
// probably a scrollbar then
|
|
if (value.LowerCaseEqualsLiteral("horizontal")) {
|
|
NS_ASSERTION(!mHScrollbarBox,
|
|
"Found multiple horizontal scrollbars?");
|
|
mHScrollbarBox = frame;
|
|
} else {
|
|
NS_ASSERTION(!mVScrollbarBox, "Found multiple vertical scrollbars?");
|
|
mVScrollbarBox = frame;
|
|
}
|
|
} else if (content->IsXULElement(nsGkAtoms::resizer)) {
|
|
NS_ASSERTION(!mResizerBox, "Found multiple resizers");
|
|
mResizerBox = frame;
|
|
} else if (content->IsXULElement(nsGkAtoms::scrollcorner)) {
|
|
// probably a scrollcorner
|
|
NS_ASSERTION(!mScrollCornerBox, "Found multiple scrollcorners");
|
|
mScrollCornerBox = frame;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
already_AddRefed<Element> ScrollFrameHelper::MakeScrollbar(
|
|
NodeInfo* aNodeInfo, bool aVertical, AnonymousContentKey& aKey) {
|
|
MOZ_ASSERT(aNodeInfo);
|
|
MOZ_ASSERT(
|
|
aNodeInfo->Equals(nsGkAtoms::scrollbar, nullptr, kNameSpaceID_XUL));
|
|
|
|
static constexpr nsLiteralString kOrientValues[2] = {
|
|
u"horizontal"_ns,
|
|
u"vertical"_ns,
|
|
};
|
|
|
|
aKey = AnonymousContentKey::Type_Scrollbar;
|
|
if (aVertical) {
|
|
aKey |= AnonymousContentKey::Flag_Vertical;
|
|
}
|
|
|
|
RefPtr<Element> e;
|
|
NS_TrustedNewXULElement(getter_AddRefs(e), do_AddRef(aNodeInfo));
|
|
|
|
#ifdef DEBUG
|
|
// Scrollbars can get restyled by theme changes. Whether such a restyle
|
|
// will actually reconstruct them correctly if it involves a frame
|
|
// reconstruct... I don't know. :(
|
|
e->SetProperty(nsGkAtoms::restylableAnonymousNode,
|
|
reinterpret_cast<void*>(true));
|
|
#endif // DEBUG
|
|
|
|
e->SetAttr(kNameSpaceID_None, nsGkAtoms::orient, kOrientValues[aVertical],
|
|
false);
|
|
e->SetAttr(kNameSpaceID_None, nsGkAtoms::clickthrough, u"always"_ns, false);
|
|
|
|
if (mIsRoot) {
|
|
e->SetProperty(nsGkAtoms::docLevelNativeAnonymousContent,
|
|
reinterpret_cast<void*>(true));
|
|
e->SetAttr(kNameSpaceID_None, nsGkAtoms::root_, u"true"_ns, false);
|
|
|
|
// Don't bother making style caching take [root="true"] styles into account.
|
|
aKey = AnonymousContentKey::None;
|
|
}
|
|
|
|
return e.forget();
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsForTextControlWithNoScrollbars() const {
|
|
// FIXME(emilio): we should probably make the scroller inside <input> an
|
|
// internal pseudo-element, and then this would be simpler.
|
|
//
|
|
// Also, this could just use scrollbar-width these days.
|
|
auto* content = mOuter->GetContent();
|
|
if (!content) {
|
|
return false;
|
|
}
|
|
auto* input = content->GetClosestNativeAnonymousSubtreeRootParent();
|
|
return input && input->IsHTMLElement(nsGkAtoms::input);
|
|
}
|
|
|
|
nsresult ScrollFrameHelper::CreateAnonymousContent(
|
|
nsTArray<nsIAnonymousContentCreator::ContentInfo>& aElements) {
|
|
typedef nsIAnonymousContentCreator::ContentInfo ContentInfo;
|
|
|
|
nsPresContext* presContext = mOuter->PresContext();
|
|
|
|
// Don't create scrollbars if we're an SVG document being used as an image,
|
|
// or if we're printing/print previewing.
|
|
// (In the printing case, we allow scrollbars if this is the child of the
|
|
// viewport & paginated scrolling is enabled, because then we must be the
|
|
// scroll frame for the print preview window, & that does need scrollbars.)
|
|
if (presContext->Document()->IsBeingUsedAsImage() ||
|
|
(!presContext->IsDynamic() &&
|
|
!(mIsRoot && presContext->HasPaginatedScrolling()))) {
|
|
mNeverHasVerticalScrollbar = mNeverHasHorizontalScrollbar = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
// Check if the frame is resizable. Note:
|
|
// "The effect of the resize property on generated content is undefined.
|
|
// Implementations should not apply the resize property to generated
|
|
// content." [1]
|
|
// For info on what is generated content, see [2].
|
|
// [1]: https://drafts.csswg.org/css-ui/#resize
|
|
// [2]: https://www.w3.org/TR/CSS2/generate.html#content
|
|
auto resizeStyle = mOuter->StyleDisplay()->mResize;
|
|
bool isResizable = resizeStyle != StyleResize::None &&
|
|
!mOuter->HasAnyStateBits(NS_FRAME_GENERATED_CONTENT);
|
|
|
|
nsIScrollableFrame* scrollable = do_QueryFrame(mOuter);
|
|
|
|
// If we're the scrollframe for the root, then we want to construct
|
|
// our scrollbar frames no matter what. That way later dynamic
|
|
// changes to propagated overflow styles will show or hide
|
|
// scrollbars on the viewport without requiring frame reconstruction
|
|
// of the viewport (good!).
|
|
bool canHaveHorizontal;
|
|
bool canHaveVertical;
|
|
if (!mIsRoot) {
|
|
if (mOuter->StyleUIReset()->mScrollbarWidth == StyleScrollbarWidth::None) {
|
|
// If scrollbar-width is none, don't generate scrollbars.
|
|
canHaveHorizontal = false;
|
|
canHaveVertical = false;
|
|
} else {
|
|
ScrollStyles styles = scrollable->GetScrollStyles();
|
|
canHaveHorizontal = styles.mHorizontal != StyleOverflow::Hidden;
|
|
canHaveVertical = styles.mVertical != StyleOverflow::Hidden;
|
|
}
|
|
if (!canHaveHorizontal && !canHaveVertical && !isResizable) {
|
|
// Nothing to do.
|
|
return NS_OK;
|
|
}
|
|
} else {
|
|
canHaveHorizontal = true;
|
|
canHaveVertical = true;
|
|
}
|
|
|
|
if (IsForTextControlWithNoScrollbars()) {
|
|
mNeverHasVerticalScrollbar = mNeverHasHorizontalScrollbar = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsNodeInfoManager* nodeInfoManager =
|
|
presContext->Document()->NodeInfoManager();
|
|
|
|
{
|
|
RefPtr<NodeInfo> nodeInfo = nodeInfoManager->GetNodeInfo(
|
|
nsGkAtoms::scrollbar, nullptr, kNameSpaceID_XUL, nsINode::ELEMENT_NODE);
|
|
NS_ENSURE_TRUE(nodeInfo, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
if (canHaveHorizontal) {
|
|
AnonymousContentKey key;
|
|
mHScrollbarContent = MakeScrollbar(nodeInfo, /* aVertical */ false, key);
|
|
aElements.AppendElement(ContentInfo(mHScrollbarContent, key));
|
|
}
|
|
|
|
if (canHaveVertical) {
|
|
AnonymousContentKey key;
|
|
mVScrollbarContent = MakeScrollbar(nodeInfo, /* aVertical */ true, key);
|
|
aElements.AppendElement(ContentInfo(mVScrollbarContent, key));
|
|
}
|
|
}
|
|
|
|
if (isResizable) {
|
|
MOZ_ASSERT(!mIsRoot, "Root scroll frame shouldn't be resizable");
|
|
|
|
AnonymousContentKey key = AnonymousContentKey::Type_Resizer;
|
|
|
|
RefPtr<NodeInfo> nodeInfo;
|
|
nodeInfo = nodeInfoManager->GetNodeInfo(
|
|
nsGkAtoms::resizer, nullptr, kNameSpaceID_XUL, nsINode::ELEMENT_NODE);
|
|
NS_ENSURE_TRUE(nodeInfo, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
NS_TrustedNewXULElement(getter_AddRefs(mResizerContent), nodeInfo.forget());
|
|
|
|
nsAutoString dir;
|
|
switch (resizeStyle) {
|
|
case StyleResize::Horizontal:
|
|
if (IsScrollbarOnRight()) {
|
|
dir.AssignLiteral("right");
|
|
key |= AnonymousContentKey::Flag_Resizer_Right;
|
|
} else {
|
|
dir.AssignLiteral("left");
|
|
}
|
|
break;
|
|
case StyleResize::Vertical:
|
|
dir.AssignLiteral("bottom");
|
|
if (!IsScrollbarOnRight()) {
|
|
mResizerContent->SetAttr(kNameSpaceID_None, nsGkAtoms::flip, u""_ns,
|
|
false);
|
|
key |= AnonymousContentKey::Flag_Resizer_Bottom_Flip;
|
|
} else {
|
|
key |= AnonymousContentKey::Flag_Resizer_Bottom;
|
|
}
|
|
break;
|
|
case StyleResize::Both:
|
|
if (IsScrollbarOnRight()) {
|
|
dir.AssignLiteral("bottomright");
|
|
key |= AnonymousContentKey::Flag_Resizer_BottomRight;
|
|
} else {
|
|
dir.AssignLiteral("bottomleft");
|
|
key |= AnonymousContentKey::Flag_Resizer_BottomLeft;
|
|
}
|
|
break;
|
|
default:
|
|
NS_WARNING("only resizable types should have resizers");
|
|
}
|
|
mResizerContent->SetAttr(kNameSpaceID_None, nsGkAtoms::dir, dir, false);
|
|
mResizerContent->SetAttr(kNameSpaceID_None, nsGkAtoms::element,
|
|
u"_parent"_ns, false);
|
|
mResizerContent->SetAttr(kNameSpaceID_None, nsGkAtoms::clickthrough,
|
|
u"always"_ns, false);
|
|
aElements.AppendElement(ContentInfo(mResizerContent, key));
|
|
}
|
|
|
|
if (canHaveHorizontal && canHaveVertical) {
|
|
AnonymousContentKey key = AnonymousContentKey::Type_ScrollCorner;
|
|
|
|
RefPtr<NodeInfo> nodeInfo =
|
|
nodeInfoManager->GetNodeInfo(nsGkAtoms::scrollcorner, nullptr,
|
|
kNameSpaceID_XUL, nsINode::ELEMENT_NODE);
|
|
NS_TrustedNewXULElement(getter_AddRefs(mScrollCornerContent),
|
|
nodeInfo.forget());
|
|
if (mIsRoot) {
|
|
mScrollCornerContent->SetProperty(
|
|
nsGkAtoms::docLevelNativeAnonymousContent,
|
|
reinterpret_cast<void*>(true));
|
|
mScrollCornerContent->SetAttr(kNameSpaceID_None, nsGkAtoms::root_,
|
|
u"true"_ns, false);
|
|
|
|
// Don't bother making style caching take [root="true"] styles into
|
|
// account.
|
|
key = AnonymousContentKey::None;
|
|
}
|
|
aElements.AppendElement(ContentInfo(mScrollCornerContent, key));
|
|
}
|
|
|
|
// Don't cache styles if we are a child of a <select> element, since we have
|
|
// some UA style sheet rules that depend on the <select>'s attributes.
|
|
if (mOuter->GetContent()->IsHTMLElement(nsGkAtoms::select)) {
|
|
for (auto& info : aElements) {
|
|
info.mKey = AnonymousContentKey::None;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void ScrollFrameHelper::AppendAnonymousContentTo(
|
|
nsTArray<nsIContent*>& aElements, uint32_t aFilter) {
|
|
if (mHScrollbarContent) {
|
|
aElements.AppendElement(mHScrollbarContent);
|
|
}
|
|
|
|
if (mVScrollbarContent) {
|
|
aElements.AppendElement(mVScrollbarContent);
|
|
}
|
|
|
|
if (mScrollCornerContent) {
|
|
aElements.AppendElement(mScrollCornerContent);
|
|
}
|
|
|
|
if (mResizerContent) {
|
|
aElements.AppendElement(mResizerContent);
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::Destroy(PostDestroyData& aPostDestroyData) {
|
|
mAnchor.Destroy();
|
|
|
|
if (mScrollbarActivity) {
|
|
mScrollbarActivity->Destroy();
|
|
mScrollbarActivity = nullptr;
|
|
}
|
|
|
|
// Unbind the content created in CreateAnonymousContent later...
|
|
aPostDestroyData.AddAnonymousContent(mHScrollbarContent.forget());
|
|
aPostDestroyData.AddAnonymousContent(mVScrollbarContent.forget());
|
|
aPostDestroyData.AddAnonymousContent(mScrollCornerContent.forget());
|
|
aPostDestroyData.AddAnonymousContent(mResizerContent.forget());
|
|
|
|
if (mPostedReflowCallback) {
|
|
mOuter->PresShell()->CancelReflowCallback(this);
|
|
mPostedReflowCallback = false;
|
|
}
|
|
|
|
if (mDisplayPortExpiryTimer) {
|
|
mDisplayPortExpiryTimer->Cancel();
|
|
mDisplayPortExpiryTimer = nullptr;
|
|
}
|
|
if (mActivityExpirationState.IsTracked()) {
|
|
gScrollFrameActivityTracker->RemoveObject(this);
|
|
}
|
|
if (gScrollFrameActivityTracker && gScrollFrameActivityTracker->IsEmpty()) {
|
|
delete gScrollFrameActivityTracker;
|
|
gScrollFrameActivityTracker = nullptr;
|
|
}
|
|
|
|
if (mScrollActivityTimer) {
|
|
mScrollActivityTimer->Cancel();
|
|
mScrollActivityTimer = nullptr;
|
|
}
|
|
RemoveObservers();
|
|
}
|
|
|
|
void ScrollFrameHelper::RemoveObservers() {
|
|
if (mAsyncScroll) {
|
|
mAsyncScroll->RemoveObserver();
|
|
mAsyncScroll = nullptr;
|
|
}
|
|
if (mAsyncSmoothMSDScroll) {
|
|
mAsyncSmoothMSDScroll->RemoveObserver();
|
|
mAsyncSmoothMSDScroll = nullptr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called when we want to update the scrollbar position, either because
|
|
* scrolling happened or the user moved the scrollbar position and we need to
|
|
* undo that (e.g., when the user clicks to scroll and we're using smooth
|
|
* scrolling, so we need to put the thumb back to its initial position for the
|
|
* start of the smooth sequence).
|
|
*/
|
|
void ScrollFrameHelper::UpdateScrollbarPosition() {
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
mFrameIsUpdatingScrollbar = true;
|
|
|
|
nsPoint pt = GetScrollPosition();
|
|
nsRect scrollRange = GetVisualScrollRange();
|
|
|
|
if (gfxPlatform::UseDesktopZoomingScrollbars()) {
|
|
pt = GetVisualViewportOffset();
|
|
scrollRange = GetScrollRangeForUserInputEvents();
|
|
}
|
|
|
|
if (mVScrollbarBox) {
|
|
SetCoordAttribute(mVScrollbarBox->GetContent()->AsElement(),
|
|
nsGkAtoms::curpos, pt.y - scrollRange.y);
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
}
|
|
if (mHScrollbarBox) {
|
|
SetCoordAttribute(mHScrollbarBox->GetContent()->AsElement(),
|
|
nsGkAtoms::curpos, pt.x - scrollRange.x);
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
mFrameIsUpdatingScrollbar = false;
|
|
}
|
|
|
|
void ScrollFrameHelper::CurPosAttributeChanged(nsIContent* aContent,
|
|
bool aDoScroll) {
|
|
NS_ASSERTION(aContent, "aContent must not be null");
|
|
NS_ASSERTION((mHScrollbarBox && mHScrollbarBox->GetContent() == aContent) ||
|
|
(mVScrollbarBox && mVScrollbarBox->GetContent() == aContent),
|
|
"unexpected child");
|
|
MOZ_ASSERT(aContent->IsElement());
|
|
|
|
// Attribute changes on the scrollbars happen in one of three ways:
|
|
// 1) The scrollbar changed the attribute in response to some user event
|
|
// 2) We changed the attribute in response to a ScrollPositionDidChange
|
|
// callback from the scrolling view
|
|
// 3) We changed the attribute to adjust the scrollbars for the start
|
|
// of a smooth scroll operation
|
|
//
|
|
// In cases 2 and 3 we do not need to scroll because we're just
|
|
// updating our scrollbar.
|
|
if (mFrameIsUpdatingScrollbar) return;
|
|
|
|
nsRect scrollRange = GetVisualScrollRange();
|
|
|
|
nsPoint current = GetScrollPosition() - scrollRange.TopLeft();
|
|
|
|
if (gfxPlatform::UseDesktopZoomingScrollbars()) {
|
|
scrollRange = GetScrollRangeForUserInputEvents();
|
|
current = GetVisualViewportOffset() - scrollRange.TopLeft();
|
|
}
|
|
|
|
nsPoint dest;
|
|
nsRect allowedRange;
|
|
dest.x = GetCoordAttribute(mHScrollbarBox, nsGkAtoms::curpos, current.x,
|
|
&allowedRange.x, &allowedRange.width);
|
|
dest.y = GetCoordAttribute(mVScrollbarBox, nsGkAtoms::curpos, current.y,
|
|
&allowedRange.y, &allowedRange.height);
|
|
current += scrollRange.TopLeft();
|
|
dest += scrollRange.TopLeft();
|
|
allowedRange += scrollRange.TopLeft();
|
|
|
|
// Don't try to scroll if we're already at an acceptable place.
|
|
// Don't call Contains here since Contains returns false when the point is
|
|
// on the bottom or right edge of the rectangle.
|
|
if (allowedRange.ClampPoint(current) == current) {
|
|
return;
|
|
}
|
|
|
|
if (mScrollbarActivity) {
|
|
RefPtr<ScrollbarActivity> scrollbarActivity(mScrollbarActivity);
|
|
scrollbarActivity->ActivityOccurred();
|
|
}
|
|
|
|
const bool isSmooth =
|
|
aContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::smooth);
|
|
if (isSmooth) {
|
|
// Make sure an attribute-setting callback occurs even if the view
|
|
// didn't actually move yet. We need to make sure other listeners
|
|
// see that the scroll position is not (yet) what they thought it
|
|
// was.
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
UpdateScrollbarPosition();
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (aDoScroll) {
|
|
ScrollToWithOrigin(dest,
|
|
isSmooth ? ScrollMode::Smooth : ScrollMode::Instant,
|
|
ScrollOrigin::Scrollbars, &allowedRange);
|
|
}
|
|
// 'this' might be destroyed here
|
|
}
|
|
|
|
/* ============= Scroll events ========== */
|
|
|
|
ScrollFrameHelper::ScrollEvent::ScrollEvent(ScrollFrameHelper* aHelper,
|
|
bool aDelayed)
|
|
: Runnable("ScrollFrameHelper::ScrollEvent"), mHelper(aHelper) {
|
|
mHelper->mOuter->PresContext()->RefreshDriver()->PostScrollEvent(this,
|
|
aDelayed);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ScrollFrameHelper::ScrollEvent::Run() {
|
|
if (mHelper) {
|
|
mHelper->FireScrollEvent();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
ScrollFrameHelper::ScrollEndEvent::ScrollEndEvent(ScrollFrameHelper* aHelper)
|
|
: Runnable("ScrollFrameHelper::ScrollEndEvent"), mHelper(aHelper) {
|
|
mHelper->mOuter->PresContext()->RefreshDriver()->PostScrollEvent(this);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ScrollFrameHelper::ScrollEndEvent::Run() {
|
|
if (mHelper) {
|
|
mHelper->FireScrollEndEvent();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void ScrollFrameHelper::FireScrollEvent() {
|
|
nsIContent* content = mOuter->GetContent();
|
|
nsPresContext* prescontext = mOuter->PresContext();
|
|
AUTO_PROFILER_TRACING_MARKER_DOCSHELL("Paint", "FireScrollEvent", GRAPHICS,
|
|
prescontext->GetDocShell());
|
|
|
|
MOZ_ASSERT(mScrollEvent);
|
|
mScrollEvent->Revoke();
|
|
mScrollEvent = nullptr;
|
|
|
|
// If event handling is suppressed, keep posting the scroll event to the
|
|
// refresh driver until it is unsuppressed. The event is marked as delayed so
|
|
// that the refresh driver does not continue ticking.
|
|
if (content->GetComposedDoc() &&
|
|
content->GetComposedDoc()->EventHandlingSuppressed()) {
|
|
content->GetComposedDoc()->SetHasDelayedRefreshEvent();
|
|
PostScrollEvent(/* aDelayed = */ true);
|
|
return;
|
|
}
|
|
|
|
bool oldProcessing = mProcessingScrollEvent;
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
auto RestoreProcessingScrollEvent = mozilla::MakeScopeExit([&] {
|
|
if (weakFrame.IsAlive()) { // Otherwise `this` will be dead too.
|
|
mProcessingScrollEvent = oldProcessing;
|
|
}
|
|
});
|
|
|
|
mProcessingScrollEvent = true;
|
|
|
|
ActiveLayerTracker::SetCurrentScrollHandlerFrame(mOuter);
|
|
WidgetGUIEvent event(true, eScroll, nullptr);
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
// Fire viewport scroll events at the document (where they
|
|
// will bubble to the window)
|
|
mozilla::layers::ScrollLinkedEffectDetector detector(
|
|
content->GetComposedDoc());
|
|
if (mIsRoot) {
|
|
if (Document* doc = content->GetUncomposedDoc()) {
|
|
EventDispatcher::Dispatch(ToSupports(doc), prescontext, &event, nullptr,
|
|
&status);
|
|
}
|
|
} else {
|
|
// scroll events fired at elements don't bubble (although scroll events
|
|
// fired at documents do, to the window)
|
|
event.mFlags.mBubbles = false;
|
|
EventDispatcher::Dispatch(content, prescontext, &event, nullptr, &status);
|
|
}
|
|
ActiveLayerTracker::SetCurrentScrollHandlerFrame(nullptr);
|
|
}
|
|
|
|
void ScrollFrameHelper::PostScrollEvent(bool aDelayed) {
|
|
if (mScrollEvent) {
|
|
return;
|
|
}
|
|
|
|
// The ScrollEvent constructor registers itself with the refresh driver.
|
|
mScrollEvent = new ScrollEvent(this, aDelayed);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
ScrollFrameHelper::AsyncScrollPortEvent::Run() {
|
|
return mHelper ? mHelper->FireScrollPortEvent() : NS_OK;
|
|
}
|
|
|
|
bool nsXULScrollFrame::AddHorizontalScrollbar(nsBoxLayoutState& aState,
|
|
bool aOnBottom) {
|
|
if (!mHelper.mHScrollbarBox) {
|
|
return true;
|
|
}
|
|
|
|
return AddRemoveScrollbar(aState, aOnBottom, true, true);
|
|
}
|
|
|
|
bool nsXULScrollFrame::AddVerticalScrollbar(nsBoxLayoutState& aState,
|
|
bool aOnRight) {
|
|
if (!mHelper.mVScrollbarBox) {
|
|
return true;
|
|
}
|
|
|
|
return AddRemoveScrollbar(aState, aOnRight, false, true);
|
|
}
|
|
|
|
void nsXULScrollFrame::RemoveHorizontalScrollbar(nsBoxLayoutState& aState,
|
|
bool aOnBottom) {
|
|
// removing a scrollbar should always fit
|
|
DebugOnly<bool> result = AddRemoveScrollbar(aState, aOnBottom, true, false);
|
|
NS_ASSERTION(result, "Removing horizontal scrollbar failed to fit??");
|
|
}
|
|
|
|
void nsXULScrollFrame::RemoveVerticalScrollbar(nsBoxLayoutState& aState,
|
|
bool aOnRight) {
|
|
// removing a scrollbar should always fit
|
|
DebugOnly<bool> result = AddRemoveScrollbar(aState, aOnRight, false, false);
|
|
NS_ASSERTION(result, "Removing vertical scrollbar failed to fit??");
|
|
}
|
|
|
|
bool nsXULScrollFrame::AddRemoveScrollbar(nsBoxLayoutState& aState,
|
|
bool aOnRightOrBottom,
|
|
bool aHorizontal, bool aAdd) {
|
|
if (aHorizontal) {
|
|
if (mHelper.mNeverHasHorizontalScrollbar || !mHelper.mHScrollbarBox) {
|
|
return false;
|
|
}
|
|
|
|
nsSize hSize = mHelper.mHScrollbarBox->GetXULPrefSize(aState);
|
|
nsIFrame::AddXULMargin(mHelper.mHScrollbarBox, hSize);
|
|
|
|
ScrollFrameHelper::SetScrollbarVisibility(mHelper.mHScrollbarBox, aAdd);
|
|
|
|
// We can't directly pass mHasHorizontalScrollbar as the bool outparam for
|
|
// AddRemoveScrollbar() because it's a bool:1 bitfield. Hence this var:
|
|
bool hasHorizontalScrollbar;
|
|
bool fit = AddRemoveScrollbar(hasHorizontalScrollbar, mHelper.mScrollPort.y,
|
|
mHelper.mScrollPort.height, hSize.height,
|
|
aOnRightOrBottom, aAdd);
|
|
mHelper.mHasHorizontalScrollbar = hasHorizontalScrollbar;
|
|
if (!fit) {
|
|
ScrollFrameHelper::SetScrollbarVisibility(mHelper.mHScrollbarBox, !aAdd);
|
|
}
|
|
return fit;
|
|
} else {
|
|
if (mHelper.mNeverHasVerticalScrollbar || !mHelper.mVScrollbarBox) {
|
|
return false;
|
|
}
|
|
|
|
nsSize vSize = mHelper.mVScrollbarBox->GetXULPrefSize(aState);
|
|
nsIFrame::AddXULMargin(mHelper.mVScrollbarBox, vSize);
|
|
|
|
ScrollFrameHelper::SetScrollbarVisibility(mHelper.mVScrollbarBox, aAdd);
|
|
|
|
// We can't directly pass mHasVerticalScrollbar as the bool outparam for
|
|
// AddRemoveScrollbar() because it's a bool:1 bitfield. Hence this var:
|
|
bool hasVerticalScrollbar;
|
|
bool fit = AddRemoveScrollbar(hasVerticalScrollbar, mHelper.mScrollPort.x,
|
|
mHelper.mScrollPort.width, vSize.width,
|
|
aOnRightOrBottom, aAdd);
|
|
mHelper.mHasVerticalScrollbar = hasVerticalScrollbar;
|
|
if (!fit) {
|
|
ScrollFrameHelper::SetScrollbarVisibility(mHelper.mVScrollbarBox, !aAdd);
|
|
}
|
|
return fit;
|
|
}
|
|
}
|
|
|
|
bool nsXULScrollFrame::AddRemoveScrollbar(bool& aHasScrollbar, nscoord& aXY,
|
|
nscoord& aSize, nscoord aSbSize,
|
|
bool aOnRightOrBottom, bool aAdd) {
|
|
nscoord size = aSize;
|
|
nscoord xy = aXY;
|
|
|
|
if (size != NS_UNCONSTRAINEDSIZE) {
|
|
if (aAdd) {
|
|
size -= aSbSize;
|
|
if (!aOnRightOrBottom && size >= 0) xy += aSbSize;
|
|
} else {
|
|
size += aSbSize;
|
|
if (!aOnRightOrBottom) xy -= aSbSize;
|
|
}
|
|
}
|
|
|
|
// not enough room? Yes? Return true.
|
|
if (size >= 0) {
|
|
aHasScrollbar = aAdd;
|
|
aSize = size;
|
|
aXY = xy;
|
|
return true;
|
|
}
|
|
|
|
aHasScrollbar = false;
|
|
return false;
|
|
}
|
|
|
|
void nsXULScrollFrame::LayoutScrollArea(nsBoxLayoutState& aState,
|
|
const nsPoint& aScrollPosition) {
|
|
ReflowChildFlags oldflags = aState.LayoutFlags();
|
|
nsRect childRect = nsRect(mHelper.mScrollPort.TopLeft() - aScrollPosition,
|
|
mHelper.mScrollPort.Size());
|
|
ReflowChildFlags flags = ReflowChildFlags::NoMoveView;
|
|
|
|
nsSize minSize = mHelper.mScrolledFrame->GetXULMinSize(aState);
|
|
|
|
if (minSize.height > childRect.height) childRect.height = minSize.height;
|
|
|
|
if (minSize.width > childRect.width) childRect.width = minSize.width;
|
|
|
|
// TODO: Handle transformed children that inherit perspective
|
|
// from this frame. See AdjustForPerspective for how we handle
|
|
// this for HTML scroll frames.
|
|
|
|
aState.SetLayoutFlags(flags);
|
|
ClampAndSetBounds(aState, childRect, aScrollPosition);
|
|
mHelper.mScrolledFrame->XULLayout(aState);
|
|
|
|
childRect = mHelper.mScrolledFrame->GetRect();
|
|
|
|
if (childRect.width < mHelper.mScrollPort.width ||
|
|
childRect.height < mHelper.mScrollPort.height) {
|
|
childRect.width = std::max(childRect.width, mHelper.mScrollPort.width);
|
|
childRect.height = std::max(childRect.height, mHelper.mScrollPort.height);
|
|
|
|
// remove overflow areas when we update the bounds,
|
|
// because we've already accounted for it
|
|
// REVIEW: Have we accounted for both?
|
|
ClampAndSetBounds(aState, childRect, aScrollPosition, true);
|
|
}
|
|
|
|
aState.SetLayoutFlags(oldflags);
|
|
}
|
|
|
|
void ScrollFrameHelper::PostOverflowEvent() {
|
|
if (mAsyncScrollPortEvent.IsPending()) {
|
|
return;
|
|
}
|
|
|
|
// Keep this in sync with FireScrollPortEvent().
|
|
nsSize scrollportSize = mScrollPort.Size();
|
|
nsSize childSize = GetScrolledRect().Size();
|
|
|
|
bool newVerticalOverflow = childSize.height > scrollportSize.height;
|
|
bool vertChanged = mVerticalOverflow != newVerticalOverflow;
|
|
|
|
bool newHorizontalOverflow = childSize.width > scrollportSize.width;
|
|
bool horizChanged = mHorizontalOverflow != newHorizontalOverflow;
|
|
|
|
if (!vertChanged && !horizChanged) {
|
|
return;
|
|
}
|
|
|
|
nsRootPresContext* rpc = mOuter->PresContext()->GetRootPresContext();
|
|
if (!rpc) {
|
|
return;
|
|
}
|
|
|
|
mAsyncScrollPortEvent = new AsyncScrollPortEvent(this);
|
|
rpc->AddWillPaintObserver(mAsyncScrollPortEvent.get());
|
|
}
|
|
|
|
nsIFrame* ScrollFrameHelper::GetFrameForStyle() const {
|
|
nsIFrame* styleFrame = nullptr;
|
|
if (mIsRoot) {
|
|
if (const Element* rootElement =
|
|
mOuter->PresContext()->Document()->GetRootElement()) {
|
|
styleFrame = rootElement->GetPrimaryFrame();
|
|
}
|
|
} else {
|
|
styleFrame = mOuter;
|
|
}
|
|
|
|
return styleFrame;
|
|
}
|
|
|
|
bool ScrollFrameHelper::NeedsScrollSnap() const {
|
|
nsIFrame* scrollSnapFrame = GetFrameForStyle();
|
|
if (!scrollSnapFrame) {
|
|
return false;
|
|
}
|
|
return scrollSnapFrame->StyleDisplay()->mScrollSnapType.strictness !=
|
|
StyleScrollSnapStrictness::None;
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsScrollbarOnRight() const {
|
|
nsPresContext* presContext = mOuter->PresContext();
|
|
|
|
// The position of the scrollbar in top-level windows depends on the pref
|
|
// layout.scrollbar.side. For non-top-level elements, it depends only on the
|
|
// directionaliy of the element (equivalent to a value of "1" for the pref).
|
|
if (!mIsRoot) {
|
|
return IsPhysicalLTR();
|
|
}
|
|
switch (presContext->GetCachedIntPref(kPresContext_ScrollbarSide)) {
|
|
default:
|
|
case 0: // UI directionality
|
|
return presContext->GetCachedIntPref(kPresContext_BidiDirection) ==
|
|
IBMBIDI_TEXTDIRECTION_LTR;
|
|
case 1: // Document / content directionality
|
|
return IsPhysicalLTR();
|
|
case 2: // Always right
|
|
return true;
|
|
case 3: // Always left
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsMaybeScrollingActive() const {
|
|
const nsStyleDisplay* disp = mOuter->StyleDisplay();
|
|
if (disp->mWillChange.bits & StyleWillChangeBits::SCROLL) {
|
|
return true;
|
|
}
|
|
|
|
nsIContent* content = mOuter->GetContent();
|
|
return mHasBeenScrolledRecently || IsAlwaysActive() ||
|
|
DisplayPortUtils::HasDisplayPort(content) ||
|
|
nsContentUtils::HasScrollgrab(content);
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsScrollingActive(
|
|
nsDisplayListBuilder* aBuilder) const {
|
|
const nsStyleDisplay* disp = mOuter->StyleDisplay();
|
|
if (disp->mWillChange.bits & StyleWillChangeBits::SCROLL &&
|
|
aBuilder->IsInWillChangeBudget(mOuter, GetVisualViewportSize())) {
|
|
return true;
|
|
}
|
|
|
|
nsIContent* content = mOuter->GetContent();
|
|
return mHasBeenScrolledRecently || IsAlwaysActive() ||
|
|
DisplayPortUtils::HasDisplayPort(content) ||
|
|
nsContentUtils::HasScrollgrab(content);
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsScrollingActiveNotMinimalDisplayPort(
|
|
nsDisplayListBuilder* aBuilder) const {
|
|
const nsStyleDisplay* disp = mOuter->StyleDisplay();
|
|
if (disp->mWillChange.bits & StyleWillChangeBits::SCROLL &&
|
|
aBuilder->IsInWillChangeBudget(mOuter, GetVisualViewportSize())) {
|
|
return true;
|
|
}
|
|
|
|
nsIContent* content = mOuter->GetContent();
|
|
return mHasBeenScrolledRecently || IsAlwaysActive() ||
|
|
DisplayPortUtils::HasNonMinimalDisplayPort(content) ||
|
|
nsContentUtils::HasScrollgrab(content);
|
|
}
|
|
|
|
/**
|
|
* Reflow the scroll area if it needs it and return its size. Also determine if
|
|
* the reflow will cause any of the scrollbars to need to be reflowed.
|
|
*/
|
|
nsresult nsXULScrollFrame::XULLayout(nsBoxLayoutState& aState) {
|
|
bool scrollbarRight = IsScrollbarOnRight();
|
|
bool scrollbarBottom = true;
|
|
|
|
// get the content rect
|
|
nsRect clientRect(0, 0, 0, 0);
|
|
GetXULClientRect(clientRect);
|
|
|
|
nsRect oldScrollAreaBounds = mHelper.mScrollPort;
|
|
nsPoint oldScrollPosition = mHelper.GetLogicalScrollPosition();
|
|
|
|
// the scroll area size starts off as big as our content area
|
|
mHelper.mScrollPort = clientRect;
|
|
|
|
/**************
|
|
Our basic strategy here is to first try laying out the content with
|
|
the scrollbars in their current state. We're hoping that that will
|
|
just "work"; the content will overflow wherever there's a scrollbar
|
|
already visible. If that does work, then there's no need to lay out
|
|
the scrollarea. Otherwise we fix up the scrollbars; first we add a
|
|
vertical one to scroll the content if necessary, or remove it if
|
|
it's not needed. Then we reflow the content if the scrollbar
|
|
changed. Then we add a horizontal scrollbar if necessary (or
|
|
remove if not needed), and if that changed, we reflow the content
|
|
again. At this point, any scrollbars that are needed to scroll the
|
|
content have been added.
|
|
|
|
In the second phase we check to see if any scrollbars are too small
|
|
to display, and if so, we remove them. We check the horizontal
|
|
scrollbar first; removing it might make room for the vertical
|
|
scrollbar, and if we have room for just one scrollbar we'll save
|
|
the vertical one.
|
|
|
|
Finally we position and size the scrollbars and scrollcorner (the
|
|
square that is needed in the corner of the window when two
|
|
scrollbars are visible), and reflow any fixed position views
|
|
(if we're the viewport and we added or removed a scrollbar).
|
|
**************/
|
|
|
|
ScrollStyles styles = GetScrollStyles();
|
|
|
|
// Look at our style do we always have vertical or horizontal scrollbars?
|
|
if (styles.mHorizontal == StyleOverflow::Scroll)
|
|
mHelper.mHasHorizontalScrollbar = true;
|
|
if (styles.mVertical == StyleOverflow::Scroll)
|
|
mHelper.mHasVerticalScrollbar = true;
|
|
|
|
if (mHelper.mHasHorizontalScrollbar)
|
|
AddHorizontalScrollbar(aState, scrollbarBottom);
|
|
|
|
if (mHelper.mHasVerticalScrollbar)
|
|
AddVerticalScrollbar(aState, scrollbarRight);
|
|
|
|
// layout our the scroll area
|
|
LayoutScrollArea(aState, oldScrollPosition);
|
|
|
|
// now look at the content area and see if we need scrollbars or not
|
|
bool needsLayout = false;
|
|
|
|
// if we have 'auto' scrollbars look at the vertical case
|
|
if (styles.mVertical != StyleOverflow::Scroll) {
|
|
// These are only good until the call to LayoutScrollArea.
|
|
nsRect scrolledRect = mHelper.GetScrolledRect();
|
|
|
|
// There are two cases to consider
|
|
if (scrolledRect.height <= mHelper.mScrollPort.height ||
|
|
styles.mVertical != StyleOverflow::Auto) {
|
|
if (mHelper.mHasVerticalScrollbar) {
|
|
// We left room for the vertical scrollbar, but it's not needed;
|
|
// remove it.
|
|
RemoveVerticalScrollbar(aState, scrollbarRight);
|
|
needsLayout = true;
|
|
}
|
|
} else {
|
|
if (!mHelper.mHasVerticalScrollbar) {
|
|
// We didn't leave room for the vertical scrollbar, but it turns
|
|
// out we needed it
|
|
if (AddVerticalScrollbar(aState, scrollbarRight)) {
|
|
needsLayout = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ok layout at the right size
|
|
if (needsLayout) {
|
|
nsBoxLayoutState resizeState(aState);
|
|
LayoutScrollArea(resizeState, oldScrollPosition);
|
|
needsLayout = false;
|
|
}
|
|
}
|
|
|
|
// if scrollbars are auto look at the horizontal case
|
|
if (styles.mHorizontal != StyleOverflow::Scroll) {
|
|
// These are only good until the call to LayoutScrollArea.
|
|
nsRect scrolledRect = mHelper.GetScrolledRect();
|
|
|
|
// if the child is wider that the scroll area
|
|
// and we don't have a scrollbar add one.
|
|
if ((scrolledRect.width > mHelper.mScrollPort.width) &&
|
|
styles.mHorizontal == StyleOverflow::Auto) {
|
|
if (!mHelper.mHasHorizontalScrollbar) {
|
|
// no scrollbar?
|
|
if (AddHorizontalScrollbar(aState, scrollbarBottom)) {
|
|
// if we added a horizontal scrollbar and we did not have a vertical
|
|
// there is a chance that by adding the horizontal scrollbar we will
|
|
// suddenly need a vertical scrollbar. Is a special case but it's
|
|
// important.
|
|
//
|
|
// But before we do that we need to relayout, since it's
|
|
// possible that the contents will flex as a result of adding a
|
|
// horizontal scrollbar and avoid the need for a vertical
|
|
// scrollbar.
|
|
//
|
|
// So instead of setting needsLayout to true here, do the
|
|
// layout immediately, and then consider whether to add the
|
|
// vertical scrollbar (and then maybe layout again).
|
|
{
|
|
nsBoxLayoutState resizeState(aState);
|
|
LayoutScrollArea(resizeState, oldScrollPosition);
|
|
needsLayout = false;
|
|
}
|
|
|
|
// Refresh scrolledRect because we called LayoutScrollArea.
|
|
scrolledRect = mHelper.GetScrolledRect();
|
|
|
|
if (styles.mVertical == StyleOverflow::Auto &&
|
|
!mHelper.mHasVerticalScrollbar &&
|
|
scrolledRect.height > mHelper.mScrollPort.height) {
|
|
if (AddVerticalScrollbar(aState, scrollbarRight)) {
|
|
needsLayout = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// if the area is smaller or equal to and we have a scrollbar then
|
|
// remove it.
|
|
if (mHelper.mHasHorizontalScrollbar) {
|
|
RemoveHorizontalScrollbar(aState, scrollbarBottom);
|
|
needsLayout = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// we only need to set the rect. The inner child stays the same size.
|
|
if (needsLayout) {
|
|
nsBoxLayoutState resizeState(aState);
|
|
LayoutScrollArea(resizeState, oldScrollPosition);
|
|
needsLayout = false;
|
|
}
|
|
|
|
// get the preferred size of the scrollbars
|
|
nsSize hMinSize(0, 0);
|
|
if (mHelper.mHScrollbarBox && mHelper.mHasHorizontalScrollbar) {
|
|
GetScrollbarMetrics(aState, mHelper.mHScrollbarBox, &hMinSize, nullptr);
|
|
}
|
|
nsSize vMinSize(0, 0);
|
|
if (mHelper.mVScrollbarBox && mHelper.mHasVerticalScrollbar) {
|
|
GetScrollbarMetrics(aState, mHelper.mVScrollbarBox, &vMinSize, nullptr);
|
|
}
|
|
|
|
// Disable scrollbars that are too small
|
|
// Disable horizontal scrollbar first. If we have to disable only one
|
|
// scrollbar, we'd rather keep the vertical scrollbar.
|
|
// Note that we always give horizontal scrollbars their preferred height,
|
|
// never their min-height. So check that there's room for the preferred
|
|
// height.
|
|
if (mHelper.mHasHorizontalScrollbar &&
|
|
(hMinSize.width > clientRect.width - vMinSize.width ||
|
|
hMinSize.height > clientRect.height)) {
|
|
RemoveHorizontalScrollbar(aState, scrollbarBottom);
|
|
needsLayout = true;
|
|
}
|
|
// Now disable vertical scrollbar if necessary
|
|
if (mHelper.mHasVerticalScrollbar &&
|
|
(vMinSize.height > clientRect.height - hMinSize.height ||
|
|
vMinSize.width > clientRect.width)) {
|
|
RemoveVerticalScrollbar(aState, scrollbarRight);
|
|
needsLayout = true;
|
|
}
|
|
|
|
// we only need to set the rect. The inner child stays the same size.
|
|
if (needsLayout) {
|
|
nsBoxLayoutState resizeState(aState);
|
|
LayoutScrollArea(resizeState, oldScrollPosition);
|
|
}
|
|
|
|
if (!mHelper.mSuppressScrollbarUpdate) {
|
|
mHelper.LayoutScrollbars(aState, clientRect, oldScrollAreaBounds);
|
|
}
|
|
if (!mHelper.mPostedReflowCallback) {
|
|
// Make sure we'll try scrolling to restored position
|
|
PresShell()->PostReflowCallback(&mHelper);
|
|
mHelper.mPostedReflowCallback = true;
|
|
}
|
|
if (!HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
|
|
mHelper.mHadNonInitialReflow = true;
|
|
}
|
|
|
|
mHelper.UpdateSticky();
|
|
|
|
// Set up overflow areas for block frames for the benefit of
|
|
// text-overflow.
|
|
nsIFrame* f = mHelper.mScrolledFrame->GetContentInsertionFrame();
|
|
if (f && f->IsBlockFrameOrSubclass()) {
|
|
nsRect origRect = f->GetRect();
|
|
nsRect clippedRect = origRect;
|
|
clippedRect.MoveBy(mHelper.mScrollPort.TopLeft());
|
|
clippedRect.IntersectRect(clippedRect, mHelper.mScrollPort);
|
|
OverflowAreas overflow = f->GetOverflowAreas();
|
|
f->FinishAndStoreOverflow(overflow, clippedRect.Size());
|
|
clippedRect.MoveTo(origRect.TopLeft());
|
|
f->SetRect(clippedRect);
|
|
}
|
|
|
|
mHelper.UpdatePrevScrolledRect();
|
|
|
|
mHelper.PostOverflowEvent();
|
|
return NS_OK;
|
|
}
|
|
|
|
void ScrollFrameHelper::FinishReflowForScrollbar(Element* aElement,
|
|
nscoord aMinXY, nscoord aMaxXY,
|
|
nscoord aCurPosXY,
|
|
nscoord aPageIncrement,
|
|
nscoord aIncrement) {
|
|
// Scrollbars assume zero is the minimum position, so translate for them.
|
|
SetCoordAttribute(aElement, nsGkAtoms::curpos, aCurPosXY - aMinXY);
|
|
SetScrollbarEnabled(aElement, aMaxXY - aMinXY);
|
|
SetCoordAttribute(aElement, nsGkAtoms::maxpos, aMaxXY - aMinXY);
|
|
SetCoordAttribute(aElement, nsGkAtoms::pageincrement, aPageIncrement);
|
|
SetCoordAttribute(aElement, nsGkAtoms::increment, aIncrement);
|
|
}
|
|
|
|
class MOZ_RAII AutoMinimumScaleSizeChangeDetector final {
|
|
public:
|
|
explicit AutoMinimumScaleSizeChangeDetector(
|
|
ScrollFrameHelper* aScrollFrameHelper)
|
|
: mHelper(aScrollFrameHelper) {
|
|
MOZ_ASSERT(mHelper);
|
|
MOZ_ASSERT(mHelper->mIsRoot);
|
|
|
|
mPreviousMinimumScaleSize = aScrollFrameHelper->mMinimumScaleSize;
|
|
mPreviousIsUsingMinimumScaleSize =
|
|
aScrollFrameHelper->mIsUsingMinimumScaleSize;
|
|
}
|
|
~AutoMinimumScaleSizeChangeDetector() {
|
|
if (mPreviousMinimumScaleSize != mHelper->mMinimumScaleSize ||
|
|
mPreviousIsUsingMinimumScaleSize != mHelper->mIsUsingMinimumScaleSize) {
|
|
mHelper->mMinimumScaleSizeChanged = true;
|
|
}
|
|
}
|
|
|
|
private:
|
|
ScrollFrameHelper* mHelper;
|
|
|
|
nsSize mPreviousMinimumScaleSize;
|
|
bool mPreviousIsUsingMinimumScaleSize;
|
|
};
|
|
|
|
nsSize ScrollFrameHelper::TrueOuterSize(nsDisplayListBuilder* aBuilder) const {
|
|
if (!mOuter->PresShell()->UsesMobileViewportSizing()) {
|
|
return mOuter->GetSize();
|
|
}
|
|
|
|
RefPtr<MobileViewportManager> manager =
|
|
mOuter->PresShell()->GetMobileViewportManager();
|
|
MOZ_ASSERT(manager);
|
|
|
|
LayoutDeviceIntSize displaySize = manager->DisplaySize();
|
|
|
|
MOZ_ASSERT(aBuilder);
|
|
// In case of WebRender, we expand the outer size to include the dynamic
|
|
// toolbar area here.
|
|
// In case of non WebRender, we expand the size dynamically in
|
|
// MoveScrollbarForLayerMargin in AsyncCompositionManager.cpp.
|
|
LayerManager* layerManager = aBuilder->GetWidgetLayerManager();
|
|
if (layerManager &&
|
|
layerManager->GetBackendType() == layers::LayersBackend::LAYERS_WR) {
|
|
displaySize.height += ViewAs<LayoutDevicePixel>(
|
|
mOuter->PresContext()->GetDynamicToolbarMaxHeight(),
|
|
PixelCastJustification::LayoutDeviceIsScreenForBounds);
|
|
}
|
|
|
|
return LayoutDeviceSize::ToAppUnits(
|
|
displaySize, mOuter->PresContext()->AppUnitsPerDevPixel());
|
|
}
|
|
|
|
void ScrollFrameHelper::UpdateMinimumScaleSize(
|
|
const nsRect& aScrollableOverflow, const nsSize& aICBSize) {
|
|
MOZ_ASSERT(mIsRoot);
|
|
|
|
AutoMinimumScaleSizeChangeDetector minimumScaleSizeChangeDetector(this);
|
|
|
|
mIsUsingMinimumScaleSize = false;
|
|
|
|
if (!mOuter->PresShell()->UsesMobileViewportSizing()) {
|
|
return;
|
|
}
|
|
|
|
nsPresContext* pc = mOuter->PresContext();
|
|
MOZ_ASSERT(pc->IsRootContentDocumentCrossProcess(),
|
|
"The pres context should be for the root content document");
|
|
|
|
RefPtr<MobileViewportManager> manager =
|
|
mOuter->PresShell()->GetMobileViewportManager();
|
|
MOZ_ASSERT(manager);
|
|
|
|
ScreenIntSize displaySize = ViewAs<ScreenPixel>(
|
|
manager->DisplaySize(),
|
|
PixelCastJustification::LayoutDeviceIsScreenForBounds);
|
|
if (displaySize.width == 0 || displaySize.height == 0) {
|
|
return;
|
|
}
|
|
if (aScrollableOverflow.IsEmpty()) {
|
|
// Bail if the scrollable overflow rect is empty, as we're going to be
|
|
// dividing by it.
|
|
return;
|
|
}
|
|
|
|
Document* doc = pc->Document();
|
|
MOZ_ASSERT(doc, "The document should be valid");
|
|
if (doc->GetFullscreenElement()) {
|
|
// Don't use the minimum scale size in the case of fullscreen state.
|
|
// FIXME: 1508177: We will no longer need this.
|
|
return;
|
|
}
|
|
|
|
nsViewportInfo viewportInfo = doc->GetViewportInfo(displaySize);
|
|
if (!viewportInfo.IsZoomAllowed()) {
|
|
// Don't apply the minimum scale size if user-scalable=no is specified.
|
|
return;
|
|
}
|
|
|
|
// The intrinsic minimum scale is the scale that fits the entire content
|
|
// width into the visual viewport.
|
|
CSSToScreenScale intrinsicMinScale(
|
|
displaySize.width / CSSRect::FromAppUnits(aScrollableOverflow).XMost());
|
|
|
|
// The scale used to compute the minimum-scale size is the larger of the
|
|
// intrinsic minimum and the min-scale from the meta viewport tag.
|
|
CSSToScreenScale minScale =
|
|
std::max(intrinsicMinScale, viewportInfo.GetMinZoom());
|
|
|
|
// The minimum-scale size is the size of the visual viewport when zoomed
|
|
// to be the minimum scale.
|
|
mMinimumScaleSize = CSSSize::ToAppUnits(ScreenSize(displaySize) / minScale);
|
|
|
|
// Ensure the minimum-scale size is never smaller than the ICB size.
|
|
// That could happen if a page has a meta viewport tag with large explicitly
|
|
// specified viewport dimensions (making the ICB large) and also a large
|
|
// minimum scale (making the min-scale size small).
|
|
mMinimumScaleSize = Max(aICBSize, mMinimumScaleSize);
|
|
|
|
mIsUsingMinimumScaleSize = true;
|
|
}
|
|
|
|
bool ScrollFrameHelper::ReflowFinished() {
|
|
mPostedReflowCallback = false;
|
|
|
|
if (mIsRoot) {
|
|
if (mMinimumScaleSizeChanged &&
|
|
mOuter->PresShell()->UsesMobileViewportSizing() &&
|
|
!mOuter->PresShell()->IsResolutionUpdatedByApz()) {
|
|
PresShell* presShell = mOuter->PresShell();
|
|
RefPtr<MobileViewportManager> manager =
|
|
presShell->GetMobileViewportManager();
|
|
MOZ_ASSERT(manager);
|
|
|
|
manager->ShrinkToDisplaySizeIfNeeded();
|
|
mMinimumScaleSizeChanged = false;
|
|
}
|
|
|
|
if (!UsesOverlayScrollbars()) {
|
|
// Layout scrollbars may have added or removed during reflow, so let's
|
|
// update the visual viewport accordingly. Note that this may be a no-op
|
|
// because we might have recomputed the visual viewport size during the
|
|
// reflow itself, just before laying out the fixed-pos items. But there
|
|
// might be cases where that code doesn't run, so this is a sort of
|
|
// backstop to ensure we do that recomputation.
|
|
if (RefPtr<MobileViewportManager> manager =
|
|
mOuter->PresShell()->GetMobileViewportManager()) {
|
|
manager->UpdateVisualViewportSizeForPotentialScrollbarChange();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool doScroll = true;
|
|
if (mOuter->IsSubtreeDirty()) {
|
|
// We will get another call after the next reflow and scrolling
|
|
// later is less janky.
|
|
doScroll = false;
|
|
}
|
|
|
|
if (mFirstReflow) {
|
|
nsPoint currentScrollPos = GetScrollPosition();
|
|
if (!mScrollUpdates.IsEmpty() &&
|
|
mScrollUpdates.LastElement().GetOrigin() == ScrollOrigin::None &&
|
|
currentScrollPos != nsPoint()) {
|
|
// With frame reconstructions, the reconstructed frame may have a nonzero
|
|
// scroll position by the end of the reflow, but without going through
|
|
// RestoreState. In particular this can happen with RTL XUL scrollframes,
|
|
// see https://bugzilla.mozilla.org/show_bug.cgi?id=1664638#c14.
|
|
// Upon construction, the ScrollFrameHelper constructor will have inserted
|
|
// a ScrollPositionUpdate into mScrollUpdates with origin None and a zero
|
|
// scroll position, but here we update that to hold the correct scroll
|
|
// position. Otherwise APZ may end up resetting the scroll position to
|
|
// zero incorrectly. If we ever hit this codepath, it must be on a reflow
|
|
// immediately following the scrollframe construction, so there should be
|
|
// exactly one ScrollPositionUpdate in mScrollUpdates.
|
|
MOZ_ASSERT(mScrollUpdates.Length() == 1);
|
|
MOZ_ASSERT(mScrollUpdates.LastElement().GetGeneration() ==
|
|
mScrollGeneration);
|
|
MOZ_ASSERT(mScrollUpdates.LastElement().GetDestination() == CSSPoint());
|
|
SCROLLRESTORE_LOG("%p: updating initial SPU to pos %s\n", this,
|
|
ToString(currentScrollPos).c_str());
|
|
mScrollUpdates.Clear();
|
|
AppendScrollUpdate(
|
|
ScrollPositionUpdate::NewScrollframe(currentScrollPos));
|
|
}
|
|
|
|
mFirstReflow = false;
|
|
}
|
|
|
|
nsAutoScriptBlocker scriptBlocker;
|
|
|
|
if (mReclampVVOffsetInReflowFinished) {
|
|
MOZ_ASSERT(mIsRoot);
|
|
mReclampVVOffsetInReflowFinished = false;
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
mOuter->PresShell()->SetVisualViewportOffset(GetVisualViewportOffset(),
|
|
GetScrollPosition());
|
|
NS_ENSURE_TRUE(weakFrame.IsAlive(), false);
|
|
}
|
|
|
|
if (doScroll) {
|
|
ScrollToRestoredPosition();
|
|
|
|
// Clamp current scroll position to new bounds. Normally this won't
|
|
// do anything.
|
|
nsPoint currentScrollPos = GetScrollPosition();
|
|
ScrollToImpl(currentScrollPos, nsRect(currentScrollPos, nsSize(0, 0)),
|
|
ScrollOrigin::Clamp);
|
|
if (!IsScrollAnimating()) {
|
|
// We need to have mDestination track the current scroll position,
|
|
// in case it falls outside the new reflow area. mDestination is used
|
|
// by ScrollBy as its starting position.
|
|
mDestination = GetScrollPosition();
|
|
}
|
|
}
|
|
|
|
if (!mUpdateScrollbarAttributes) {
|
|
return false;
|
|
}
|
|
mUpdateScrollbarAttributes = false;
|
|
|
|
// Update scrollbar attributes.
|
|
if (mMayHaveDirtyFixedChildren) {
|
|
mMayHaveDirtyFixedChildren = false;
|
|
nsIFrame* parentFrame = mOuter->GetParent();
|
|
for (nsIFrame* fixedChild =
|
|
parentFrame->GetChildList(nsIFrame::kFixedList).FirstChild();
|
|
fixedChild; fixedChild = fixedChild->GetNextSibling()) {
|
|
// force a reflow of the fixed child
|
|
mOuter->PresShell()->FrameNeedsReflow(fixedChild, IntrinsicDirty::Resize,
|
|
NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
}
|
|
}
|
|
|
|
// Suppress handling of the curpos attribute changes we make here.
|
|
NS_ASSERTION(!mFrameIsUpdatingScrollbar, "We shouldn't be reentering here");
|
|
mFrameIsUpdatingScrollbar = true;
|
|
|
|
// FIXME(emilio): Why this instead of mHScrollbarContent / mVScrollbarContent?
|
|
RefPtr<Element> vScroll =
|
|
mVScrollbarBox ? mVScrollbarBox->GetContent()->AsElement() : nullptr;
|
|
RefPtr<Element> hScroll =
|
|
mHScrollbarBox ? mHScrollbarBox->GetContent()->AsElement() : nullptr;
|
|
|
|
// Note, in some cases mOuter may get deleted while finishing reflow
|
|
// for scrollbars. XXXmats is this still true now that we have a script
|
|
// blocker in this scope? (if not, remove the weak frame checks below).
|
|
if (vScroll || hScroll) {
|
|
nsSize visualViewportSize = GetVisualViewportSize();
|
|
nsRect scrollRange = GetVisualScrollRange();
|
|
nsPoint scrollPos = GetScrollPosition();
|
|
nsSize lineScrollAmount = GetLineScrollAmount();
|
|
|
|
if (gfxPlatform::UseDesktopZoomingScrollbars()) {
|
|
scrollRange = GetScrollRangeForUserInputEvents();
|
|
scrollPos = GetVisualViewportOffset();
|
|
}
|
|
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
if (vScroll) {
|
|
const double kScrollMultiplier =
|
|
Preferences::GetInt("toolkit.scrollbox.verticalScrollDistance",
|
|
NS_DEFAULT_VERTICAL_SCROLL_DISTANCE);
|
|
nscoord increment = lineScrollAmount.height * kScrollMultiplier;
|
|
// We normally use (visualViewportSize.height - increment) for height of
|
|
// page scrolling. However, it is too small when increment is very large.
|
|
// (If increment is larger than visualViewportSize.height, direction of
|
|
// scrolling will be opposite). To avoid it, we use
|
|
// (float(visualViewportSize.height) * 0.8) as lower bound value of height
|
|
// of page scrolling. (bug 383267)
|
|
// XXX shouldn't we use GetPageScrollAmount here?
|
|
nscoord pageincrement = nscoord(visualViewportSize.height - increment);
|
|
nscoord pageincrementMin =
|
|
nscoord(float(visualViewportSize.height) * 0.8);
|
|
FinishReflowForScrollbar(
|
|
vScroll, scrollRange.y, scrollRange.YMost(), scrollPos.y,
|
|
std::max(pageincrement, pageincrementMin), increment);
|
|
}
|
|
if (hScroll) {
|
|
const double kScrollMultiplier =
|
|
Preferences::GetInt("toolkit.scrollbox.horizontalScrollDistance",
|
|
NS_DEFAULT_HORIZONTAL_SCROLL_DISTANCE);
|
|
nscoord increment = lineScrollAmount.width * kScrollMultiplier;
|
|
FinishReflowForScrollbar(
|
|
hScroll, scrollRange.x, scrollRange.XMost(), scrollPos.x,
|
|
nscoord(float(visualViewportSize.width) * 0.8), increment);
|
|
}
|
|
NS_ENSURE_TRUE(weakFrame.IsAlive(), false);
|
|
}
|
|
|
|
mFrameIsUpdatingScrollbar = false;
|
|
// We used to rely on the curpos attribute changes above to scroll the
|
|
// view. However, for scrolling to the left of the viewport, we
|
|
// rescale the curpos attribute, which means that operations like
|
|
// resizing the window while it is scrolled all the way to the left
|
|
// hold the curpos attribute constant at 0 while still requiring
|
|
// scrolling. So we suppress the effect of the changes above with
|
|
// mFrameIsUpdatingScrollbar and call CurPosAttributeChanged here.
|
|
// (It actually even works some of the time without this, thanks to
|
|
// nsSliderFrame::AttributeChanged's handling of maxpos, but not when
|
|
// we hide the scrollbar on a large size change, such as
|
|
// maximization.)
|
|
if (!mHScrollbarBox && !mVScrollbarBox) return false;
|
|
CurPosAttributeChanged(mVScrollbarBox
|
|
? mVScrollbarBox->GetContent()->AsElement()
|
|
: mHScrollbarBox->GetContent()->AsElement(),
|
|
doScroll);
|
|
return doScroll;
|
|
}
|
|
|
|
void ScrollFrameHelper::ReflowCallbackCanceled() {
|
|
mPostedReflowCallback = false;
|
|
}
|
|
|
|
bool ScrollFrameHelper::ComputeCustomOverflow(OverflowAreas& aOverflowAreas) {
|
|
nsIScrollableFrame* sf = do_QueryFrame(mOuter);
|
|
ScrollStyles ss = sf->GetScrollStyles();
|
|
|
|
// Reflow when the change in overflow leads to one of our scrollbars
|
|
// changing or might require repositioning the scrolled content due to
|
|
// reduced extents.
|
|
nsRect scrolledRect = GetScrolledRect();
|
|
ScrollDirections overflowChange =
|
|
GetOverflowChange(scrolledRect, mPrevScrolledRect);
|
|
mPrevScrolledRect = scrolledRect;
|
|
|
|
bool needReflow = false;
|
|
nsPoint scrollPosition = GetScrollPosition();
|
|
if (overflowChange.contains(ScrollDirection::eHorizontal)) {
|
|
if (ss.mHorizontal != StyleOverflow::Hidden || scrollPosition.x) {
|
|
needReflow = true;
|
|
}
|
|
}
|
|
if (overflowChange.contains(ScrollDirection::eVertical)) {
|
|
if (ss.mVertical != StyleOverflow::Hidden || scrollPosition.y) {
|
|
needReflow = true;
|
|
}
|
|
}
|
|
|
|
if (needReflow) {
|
|
// If there are scrollbars, or we're not at the beginning of the pane,
|
|
// the scroll position may change. In this case, mark the frame as
|
|
// needing reflow. Don't use NS_FRAME_IS_DIRTY as dirty as that means
|
|
// we have to reflow the frame and all its descendants, and we don't
|
|
// have to do that here. Only this frame needs to be reflowed.
|
|
mOuter->PresShell()->FrameNeedsReflow(mOuter, IntrinsicDirty::Resize,
|
|
NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
// Ensure that next time nsHTMLScrollFrame::Reflow runs, we don't skip
|
|
// updating the scrollbars. (Because the overflow area of the scrolled
|
|
// frame has probably just been updated, Reflow won't see it change.)
|
|
mSkippedScrollbarLayout = true;
|
|
return false; // reflowing will update overflow
|
|
}
|
|
PostOverflowEvent();
|
|
return mOuter->nsContainerFrame::ComputeCustomOverflow(aOverflowAreas);
|
|
}
|
|
|
|
void ScrollFrameHelper::UpdateSticky() {
|
|
StickyScrollContainer* ssc =
|
|
StickyScrollContainer::GetStickyScrollContainerForScrollFrame(mOuter);
|
|
if (ssc) {
|
|
nsIScrollableFrame* scrollFrame = do_QueryFrame(mOuter);
|
|
ssc->UpdatePositions(scrollFrame->GetScrollPosition(), mOuter);
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::UpdatePrevScrolledRect() {
|
|
mPrevScrolledRect = GetScrolledRect();
|
|
}
|
|
|
|
void ScrollFrameHelper::AdjustScrollbarRectForResizer(
|
|
nsIFrame* aFrame, nsPresContext* aPresContext, nsRect& aRect,
|
|
bool aHasResizer, ScrollDirection aDirection) {
|
|
if ((aDirection == ScrollDirection::eVertical ? aRect.width : aRect.height) ==
|
|
0) {
|
|
return;
|
|
}
|
|
|
|
// if a content resizer is present, use its size. Otherwise, check if the
|
|
// widget has a resizer.
|
|
nsRect resizerRect;
|
|
if (aHasResizer) {
|
|
resizerRect = mResizerBox->GetRect();
|
|
} else {
|
|
nsPoint offset;
|
|
nsIWidget* widget = aFrame->GetNearestWidget(offset);
|
|
LayoutDeviceIntRect widgetRect;
|
|
if (!widget || !widget->ShowsResizeIndicator(&widgetRect)) {
|
|
return;
|
|
}
|
|
|
|
resizerRect =
|
|
nsRect(aPresContext->DevPixelsToAppUnits(widgetRect.x) - offset.x,
|
|
aPresContext->DevPixelsToAppUnits(widgetRect.y) - offset.y,
|
|
aPresContext->DevPixelsToAppUnits(widgetRect.width),
|
|
aPresContext->DevPixelsToAppUnits(widgetRect.height));
|
|
}
|
|
|
|
if (resizerRect.Contains(aRect.BottomRight() - nsPoint(1, 1))) {
|
|
switch (aDirection) {
|
|
case ScrollDirection::eVertical:
|
|
aRect.height = std::max(0, resizerRect.y - aRect.y);
|
|
break;
|
|
case ScrollDirection::eHorizontal:
|
|
aRect.width = std::max(0, resizerRect.x - aRect.x);
|
|
break;
|
|
}
|
|
} else if (resizerRect.Contains(aRect.BottomLeft() + nsPoint(1, -1))) {
|
|
switch (aDirection) {
|
|
case ScrollDirection::eVertical:
|
|
aRect.height = std::max(0, resizerRect.y - aRect.y);
|
|
break;
|
|
case ScrollDirection::eHorizontal: {
|
|
nscoord xmost = aRect.XMost();
|
|
aRect.x = std::max(aRect.x, resizerRect.XMost());
|
|
aRect.width = xmost - aRect.x;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void AdjustOverlappingScrollbars(nsRect& aVRect, nsRect& aHRect) {
|
|
if (aVRect.IsEmpty() || aHRect.IsEmpty()) return;
|
|
|
|
const nsRect oldVRect = aVRect;
|
|
const nsRect oldHRect = aHRect;
|
|
if (oldVRect.Contains(oldHRect.BottomRight() - nsPoint(1, 1))) {
|
|
aHRect.width = std::max(0, oldVRect.x - oldHRect.x);
|
|
} else if (oldVRect.Contains(oldHRect.BottomLeft() - nsPoint(0, 1))) {
|
|
nscoord overlap = std::min(oldHRect.width, oldVRect.XMost() - oldHRect.x);
|
|
aHRect.x += overlap;
|
|
aHRect.width -= overlap;
|
|
}
|
|
if (oldHRect.Contains(oldVRect.BottomRight() - nsPoint(1, 1))) {
|
|
aVRect.height = std::max(0, oldHRect.y - oldVRect.y);
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::LayoutScrollbars(nsBoxLayoutState& aState,
|
|
const nsRect& aContentArea,
|
|
const nsRect& aOldScrollArea) {
|
|
NS_ASSERTION(!mSuppressScrollbarUpdate, "This should have been suppressed");
|
|
|
|
bool hasResizer = HasResizer();
|
|
bool scrollbarOnLeft = !IsScrollbarOnRight();
|
|
bool overlayScrollBarsOnRoot = UsesOverlayScrollbars() && mIsRoot;
|
|
|
|
nsSize compositionSize = mScrollPort.Size();
|
|
if (overlayScrollBarsOnRoot) {
|
|
compositionSize = nsLayoutUtils::CalculateCompositionSizeForFrame(
|
|
mOuter, false, &compositionSize);
|
|
}
|
|
|
|
nsPresContext* presContext = mScrolledFrame->PresContext();
|
|
nsRect vRect;
|
|
if (mVScrollbarBox) {
|
|
MOZ_ASSERT(mVScrollbarBox->IsXULBoxFrame(), "Must be a box frame!");
|
|
vRect = mScrollPort;
|
|
if (overlayScrollBarsOnRoot) {
|
|
vRect.height = compositionSize.height;
|
|
}
|
|
vRect.width = aContentArea.width - mScrollPort.width;
|
|
vRect.x = scrollbarOnLeft ? aContentArea.x
|
|
: mScrollPort.x + compositionSize.width;
|
|
if (mHasVerticalScrollbar) {
|
|
nsMargin margin;
|
|
|
|
// For overlay scrollbars the margin returned from this GetXULMargin call
|
|
// is a negative margin that moves the scrollbar from just outside the
|
|
// scrollport (and hence not visible) to just inside the scrollport (and
|
|
// hence visible). For non-overlay scrollbars it is a 0 margin.
|
|
mVScrollbarBox->GetXULMargin(margin);
|
|
|
|
if (!UsesOverlayScrollbars() && mOnlyNeedVScrollbarToScrollVVInsideLV) {
|
|
// There is no space reserved for the layout scrollbar, it is currently
|
|
// not visible because it is positioned just outside the scrollport. But
|
|
// we know that it needs to be made visible so we shift it back in.
|
|
nsSize vScrollbarPrefSize(0, 0);
|
|
GetScrollbarMetrics(aState, mVScrollbarBox, nullptr,
|
|
&vScrollbarPrefSize);
|
|
if (scrollbarOnLeft) {
|
|
margin.right -= vScrollbarPrefSize.width;
|
|
} else {
|
|
margin.left -= vScrollbarPrefSize.width;
|
|
}
|
|
}
|
|
|
|
vRect.Deflate(margin);
|
|
}
|
|
}
|
|
|
|
bool hasVisualOnlyScrollbarsOnBothDirections =
|
|
!UsesOverlayScrollbars() && mHScrollbarBox && mHasHorizontalScrollbar &&
|
|
mOnlyNeedHScrollbarToScrollVVInsideLV && mVScrollbarBox &&
|
|
mHasVerticalScrollbar && mOnlyNeedVScrollbarToScrollVVInsideLV;
|
|
|
|
nsRect hRect;
|
|
if (mHScrollbarBox) {
|
|
MOZ_ASSERT(mHScrollbarBox->IsXULBoxFrame(), "Must be a box frame!");
|
|
hRect = mScrollPort;
|
|
if (overlayScrollBarsOnRoot) {
|
|
hRect.width = compositionSize.width;
|
|
}
|
|
hRect.height = aContentArea.height - mScrollPort.height;
|
|
hRect.y = mScrollPort.y + compositionSize.height;
|
|
if (mHasHorizontalScrollbar) {
|
|
nsMargin margin;
|
|
|
|
// For overlay scrollbars the margin returned from this GetXULMargin call
|
|
// is a negative margin that moves the scrollbar from just outside the
|
|
// scrollport (and hence not visible) to just inside the scrollport (and
|
|
// hence visible). For non-overlay scrollbars it is a 0 margin.
|
|
mHScrollbarBox->GetXULMargin(margin);
|
|
|
|
if (!UsesOverlayScrollbars() && mOnlyNeedHScrollbarToScrollVVInsideLV) {
|
|
// There is no space reserved for the layout scrollbar, it is currently
|
|
// not visible because it is positioned just outside the scrollport. But
|
|
// we know that it needs to be made visible so we shift it back in.
|
|
nsSize hScrollbarPrefSize(0, 0);
|
|
GetScrollbarMetrics(aState, mHScrollbarBox, nullptr,
|
|
&hScrollbarPrefSize);
|
|
margin.top -= hScrollbarPrefSize.height;
|
|
}
|
|
|
|
hRect.Deflate(margin);
|
|
}
|
|
}
|
|
|
|
// place the scrollcorner
|
|
if (mScrollCornerBox || mResizerBox) {
|
|
MOZ_ASSERT(!mScrollCornerBox || mScrollCornerBox->IsXULBoxFrame(),
|
|
"Must be a box frame!");
|
|
|
|
nsRect r(0, 0, 0, 0);
|
|
if (aContentArea.x != mScrollPort.x || scrollbarOnLeft) {
|
|
// scrollbar (if any) on left
|
|
r.x = aContentArea.x;
|
|
r.width = mScrollPort.x - aContentArea.x;
|
|
NS_ASSERTION(r.width >= 0, "Scroll area should be inside client rect");
|
|
} else {
|
|
// scrollbar (if any) on right
|
|
r.width = aContentArea.XMost() - mScrollPort.XMost();
|
|
r.x = aContentArea.XMost() - r.width;
|
|
NS_ASSERTION(r.width >= 0, "Scroll area should be inside client rect");
|
|
}
|
|
if (aContentArea.y != mScrollPort.y) {
|
|
NS_ERROR("top scrollbars not supported");
|
|
} else {
|
|
// scrollbar (if any) on bottom
|
|
r.height = aContentArea.YMost() - mScrollPort.YMost();
|
|
r.y = aContentArea.YMost() - r.height;
|
|
NS_ASSERTION(r.height >= 0, "Scroll area should be inside client rect");
|
|
}
|
|
|
|
// If we have layout scrollbars and both scrollbars are present and both are
|
|
// only needed to scroll the VV inside the LV then we need a scrollcorner
|
|
// but the above calculation will result in an empty rect, so adjust it.
|
|
if (r.IsEmpty() && hasVisualOnlyScrollbarsOnBothDirections) {
|
|
r.width = vRect.width;
|
|
r.height = hRect.height;
|
|
r.x = scrollbarOnLeft ? mScrollPort.x : mScrollPort.XMost() - r.width;
|
|
r.y = mScrollPort.YMost() - r.height;
|
|
}
|
|
|
|
if (mScrollCornerBox) {
|
|
nsBoxFrame::LayoutChildAt(aState, mScrollCornerBox, r);
|
|
}
|
|
|
|
if (hasResizer) {
|
|
// If a resizer is present, get its size.
|
|
//
|
|
// TODO(emilio): Should this really account for scrollbar-width?
|
|
nsPresContext* pc = aState.PresContext();
|
|
auto scrollbarWidth = nsLayoutUtils::StyleForScrollbar(mOuter)
|
|
->StyleUIReset()
|
|
->mScrollbarWidth;
|
|
auto sizes = pc->Theme()->GetScrollbarSizes(pc, scrollbarWidth,
|
|
nsITheme::Overlay::No);
|
|
nsSize resizerMinSize = mResizerBox->GetXULMinSize(aState);
|
|
|
|
nscoord vScrollbarWidth = pc->DevPixelsToAppUnits(sizes.mVertical);
|
|
r.width =
|
|
std::max(std::max(r.width, vScrollbarWidth), resizerMinSize.width);
|
|
if (aContentArea.x == mScrollPort.x && !scrollbarOnLeft) {
|
|
r.x = aContentArea.XMost() - r.width;
|
|
}
|
|
|
|
nscoord hScrollbarHeight = pc->DevPixelsToAppUnits(sizes.mHorizontal);
|
|
r.height =
|
|
std::max(std::max(r.height, hScrollbarHeight), resizerMinSize.height);
|
|
if (aContentArea.y == mScrollPort.y) {
|
|
r.y = aContentArea.YMost() - r.height;
|
|
}
|
|
|
|
nsBoxFrame::LayoutChildAt(aState, mResizerBox, r);
|
|
} else if (mResizerBox) {
|
|
// otherwise lay out the resizer with an empty rectangle
|
|
nsBoxFrame::LayoutChildAt(aState, mResizerBox, nsRect());
|
|
}
|
|
}
|
|
|
|
// Note that AdjustScrollbarRectForResizer has to be called after the
|
|
// resizer has been laid out immediately above this because it gets the rect
|
|
// of the resizer frame.
|
|
if (mVScrollbarBox) {
|
|
AdjustScrollbarRectForResizer(mOuter, presContext, vRect, hasResizer,
|
|
ScrollDirection::eVertical);
|
|
}
|
|
if (mHScrollbarBox) {
|
|
AdjustScrollbarRectForResizer(mOuter, presContext, hRect, hasResizer,
|
|
ScrollDirection::eHorizontal);
|
|
}
|
|
|
|
// Layout scrollbars can overlap at this point if they are both present and
|
|
// both only needed to scroll the VV inside the LV.
|
|
if (!LookAndFeel::GetInt(LookAndFeel::IntID::AllowOverlayScrollbarsOverlap) ||
|
|
hasVisualOnlyScrollbarsOnBothDirections) {
|
|
AdjustOverlappingScrollbars(vRect, hRect);
|
|
}
|
|
if (mVScrollbarBox) {
|
|
nsBoxFrame::LayoutChildAt(aState, mVScrollbarBox, vRect);
|
|
}
|
|
if (mHScrollbarBox) {
|
|
nsBoxFrame::LayoutChildAt(aState, mHScrollbarBox, hRect);
|
|
}
|
|
|
|
// may need to update fixed position children of the viewport,
|
|
// if the client area changed size because of an incremental
|
|
// reflow of a descendant. (If the outer frame is dirty, the fixed
|
|
// children will be re-laid out anyway)
|
|
if (aOldScrollArea.Size() != mScrollPort.Size() &&
|
|
!mOuter->HasAnyStateBits(NS_FRAME_IS_DIRTY) && mIsRoot) {
|
|
mMayHaveDirtyFixedChildren = true;
|
|
}
|
|
|
|
// post reflow callback to modify scrollbar attributes
|
|
mUpdateScrollbarAttributes = true;
|
|
if (!mPostedReflowCallback) {
|
|
aState.PresShell()->PostReflowCallback(this);
|
|
mPostedReflowCallback = true;
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
static bool ShellIsAlive(nsWeakPtr& aWeakPtr) {
|
|
RefPtr<PresShell> presShell = do_QueryReferent(aWeakPtr);
|
|
return !!presShell;
|
|
}
|
|
#endif
|
|
|
|
void ScrollFrameHelper::SetScrollbarEnabled(Element* aElement,
|
|
nscoord aMaxPos) {
|
|
DebugOnly<nsWeakPtr> weakShell(do_GetWeakReference(mOuter->PresShell()));
|
|
if (aMaxPos) {
|
|
aElement->UnsetAttr(kNameSpaceID_None, nsGkAtoms::disabled, true);
|
|
} else {
|
|
aElement->SetAttr(kNameSpaceID_None, nsGkAtoms::disabled, u"true"_ns, true);
|
|
}
|
|
MOZ_ASSERT(ShellIsAlive(weakShell), "pres shell was destroyed by scrolling");
|
|
}
|
|
|
|
void ScrollFrameHelper::SetCoordAttribute(Element* aElement, nsAtom* aAtom,
|
|
nscoord aSize) {
|
|
DebugOnly<nsWeakPtr> weakShell(do_GetWeakReference(mOuter->PresShell()));
|
|
// convert to pixels
|
|
int32_t pixelSize = nsPresContext::AppUnitsToIntCSSPixels(aSize);
|
|
|
|
// only set the attribute if it changed.
|
|
|
|
nsAutoString newValue;
|
|
newValue.AppendInt(pixelSize);
|
|
|
|
if (aElement->AttrValueIs(kNameSpaceID_None, aAtom, newValue, eCaseMatters)) {
|
|
return;
|
|
}
|
|
|
|
AutoWeakFrame weakFrame(mOuter);
|
|
RefPtr<Element> kungFuDeathGrip = aElement;
|
|
aElement->SetAttr(kNameSpaceID_None, aAtom, newValue, true);
|
|
MOZ_ASSERT(ShellIsAlive(weakShell), "pres shell was destroyed by scrolling");
|
|
if (!weakFrame.IsAlive()) {
|
|
return;
|
|
}
|
|
|
|
if (mScrollbarActivity) {
|
|
RefPtr<ScrollbarActivity> scrollbarActivity(mScrollbarActivity);
|
|
scrollbarActivity->ActivityOccurred();
|
|
}
|
|
}
|
|
|
|
static void ReduceRadii(nscoord aXBorder, nscoord aYBorder, nscoord& aXRadius,
|
|
nscoord& aYRadius) {
|
|
// In order to ensure that the inside edge of the border has no
|
|
// curvature, we need at least one of its radii to be zero.
|
|
if (aXRadius <= aXBorder || aYRadius <= aYBorder) return;
|
|
|
|
// For any corner where we reduce the radii, preserve the corner's shape.
|
|
double ratio =
|
|
std::max(double(aXBorder) / aXRadius, double(aYBorder) / aYRadius);
|
|
aXRadius *= ratio;
|
|
aYRadius *= ratio;
|
|
}
|
|
|
|
/**
|
|
* Implement an override for nsIFrame::GetBorderRadii to ensure that
|
|
* the clipping region for the border radius does not clip the scrollbars.
|
|
*
|
|
* In other words, we require that the border radius be reduced until the
|
|
* inner border radius at the inner edge of the border is 0 wherever we
|
|
* have scrollbars.
|
|
*/
|
|
bool ScrollFrameHelper::GetBorderRadii(const nsSize& aFrameSize,
|
|
const nsSize& aBorderArea,
|
|
Sides aSkipSides,
|
|
nscoord aRadii[8]) const {
|
|
if (!mOuter->nsContainerFrame::GetBorderRadii(aFrameSize, aBorderArea,
|
|
aSkipSides, aRadii)) {
|
|
return false;
|
|
}
|
|
|
|
// Since we can use GetActualScrollbarSizes (rather than
|
|
// GetDesiredScrollbarSizes) since this doesn't affect reflow, we
|
|
// probably should.
|
|
nsMargin sb = GetActualScrollbarSizes();
|
|
nsMargin border = mOuter->GetUsedBorder();
|
|
|
|
if (sb.left > 0 || sb.top > 0) {
|
|
ReduceRadii(border.left, border.top, aRadii[eCornerTopLeftX],
|
|
aRadii[eCornerTopLeftY]);
|
|
}
|
|
|
|
if (sb.top > 0 || sb.right > 0) {
|
|
ReduceRadii(border.right, border.top, aRadii[eCornerTopRightX],
|
|
aRadii[eCornerTopRightY]);
|
|
}
|
|
|
|
if (sb.right > 0 || sb.bottom > 0) {
|
|
ReduceRadii(border.right, border.bottom, aRadii[eCornerBottomRightX],
|
|
aRadii[eCornerBottomRightY]);
|
|
}
|
|
|
|
if (sb.bottom > 0 || sb.left > 0) {
|
|
ReduceRadii(border.left, border.bottom, aRadii[eCornerBottomLeftX],
|
|
aRadii[eCornerBottomLeftY]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static nscoord SnapCoord(nscoord aCoord, double aRes,
|
|
nscoord aAppUnitsPerPixel) {
|
|
double snappedToLayerPixels = NS_round((aRes * aCoord) / aAppUnitsPerPixel);
|
|
return NSToCoordRoundWithClamp(snappedToLayerPixels * aAppUnitsPerPixel /
|
|
aRes);
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::GetScrolledRect() const {
|
|
nsRect result = GetUnsnappedScrolledRectInternal(
|
|
mScrolledFrame->ScrollableOverflowRect(), mScrollPort.Size());
|
|
|
|
if (result.width < mScrollPort.width) {
|
|
NS_WARNING("Scrolled rect smaller than scrollport?");
|
|
}
|
|
if (result.height < mScrollPort.height) {
|
|
NS_WARNING("Scrolled rect smaller than scrollport?");
|
|
}
|
|
|
|
// Expand / contract the result by up to half a layer pixel so that scrolling
|
|
// to the right / bottom edge does not change the layer pixel alignment of
|
|
// the scrolled contents.
|
|
|
|
if (result.x == 0 && result.y == 0 && result.width == mScrollPort.width &&
|
|
result.height == mScrollPort.height) {
|
|
// The edges that we would snap are already aligned with the scroll port,
|
|
// so we can skip all the work below.
|
|
return result;
|
|
}
|
|
|
|
// For that, we first convert the scroll port and the scrolled rect to rects
|
|
// relative to the reference frame, since that's the space where painting does
|
|
// snapping.
|
|
nsSize visualViewportSize = GetVisualViewportSize();
|
|
const nsIFrame* referenceFrame =
|
|
mReferenceFrameDuringPainting ? mReferenceFrameDuringPainting
|
|
: nsLayoutUtils::GetReferenceFrame(mOuter);
|
|
nsPoint toReferenceFrame = mOuter->GetOffsetToCrossDoc(referenceFrame);
|
|
nsRect scrollPort(mScrollPort.TopLeft() + toReferenceFrame,
|
|
visualViewportSize);
|
|
nsRect scrolledRect = result + scrollPort.TopLeft();
|
|
|
|
if (scrollPort.Overflows() || scrolledRect.Overflows()) {
|
|
return result;
|
|
}
|
|
|
|
// Now, snap the bottom right corner of both of these rects.
|
|
// We snap to layer pixels, so we need to respect the layer's scale.
|
|
nscoord appUnitsPerDevPixel =
|
|
mScrolledFrame->PresContext()->AppUnitsPerDevPixel();
|
|
gfxSize scale =
|
|
FrameLayerBuilder::GetPaintedLayerScaleForFrame(mScrolledFrame);
|
|
if (scale.IsEmpty()) {
|
|
scale = gfxSize(1.0f, 1.0f);
|
|
}
|
|
|
|
// Compute bounds for the scroll position, and computed the snapped scrolled
|
|
// rect from the scroll position bounds.
|
|
nscoord snappedScrolledAreaBottom =
|
|
SnapCoord(scrolledRect.YMost(), scale.height, appUnitsPerDevPixel);
|
|
nscoord snappedScrollPortBottom =
|
|
SnapCoord(scrollPort.YMost(), scale.height, appUnitsPerDevPixel);
|
|
nscoord maximumScrollOffsetY =
|
|
snappedScrolledAreaBottom - snappedScrollPortBottom;
|
|
result.SetBottomEdge(scrollPort.height + maximumScrollOffsetY);
|
|
|
|
if (GetScrolledFrameDir() == StyleDirection::Ltr) {
|
|
nscoord snappedScrolledAreaRight =
|
|
SnapCoord(scrolledRect.XMost(), scale.width, appUnitsPerDevPixel);
|
|
nscoord snappedScrollPortRight =
|
|
SnapCoord(scrollPort.XMost(), scale.width, appUnitsPerDevPixel);
|
|
nscoord maximumScrollOffsetX =
|
|
snappedScrolledAreaRight - snappedScrollPortRight;
|
|
result.SetRightEdge(scrollPort.width + maximumScrollOffsetX);
|
|
} else {
|
|
// In RTL, the scrolled area's right edge is at scrollPort.XMost(),
|
|
// and the scrolled area's x position is zero or negative. We want
|
|
// the right edge to stay flush with the scroll port, so we snap the
|
|
// left edge.
|
|
nscoord snappedScrolledAreaLeft =
|
|
SnapCoord(scrolledRect.x, scale.width, appUnitsPerDevPixel);
|
|
nscoord snappedScrollPortLeft =
|
|
SnapCoord(scrollPort.x, scale.width, appUnitsPerDevPixel);
|
|
nscoord minimumScrollOffsetX =
|
|
snappedScrolledAreaLeft - snappedScrollPortLeft;
|
|
result.SetLeftEdge(minimumScrollOffsetX);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
StyleDirection ScrollFrameHelper::GetScrolledFrameDir() const {
|
|
// If the scrolled frame has unicode-bidi: plaintext, the paragraph
|
|
// direction set by the text content overrides the direction of the frame
|
|
if (mScrolledFrame->StyleTextReset()->mUnicodeBidi &
|
|
NS_STYLE_UNICODE_BIDI_PLAINTEXT) {
|
|
if (nsIFrame* child = mScrolledFrame->PrincipalChildList().FirstChild()) {
|
|
return nsBidiPresUtils::ParagraphDirection(child) == NSBIDI_LTR
|
|
? StyleDirection::Ltr
|
|
: StyleDirection::Rtl;
|
|
}
|
|
}
|
|
return IsBidiLTR() ? StyleDirection::Ltr : StyleDirection::Rtl;
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::GetUnsnappedScrolledRectInternal(
|
|
const nsRect& aScrolledFrameOverflowArea,
|
|
const nsSize& aScrollPortSize) const {
|
|
return nsLayoutUtils::GetScrolledRect(mScrolledFrame,
|
|
aScrolledFrameOverflowArea,
|
|
aScrollPortSize, GetScrolledFrameDir());
|
|
}
|
|
|
|
nsMargin ScrollFrameHelper::GetActualScrollbarSizes(
|
|
nsIScrollableFrame::ScrollbarSizesOptions
|
|
aOptions /* = nsIScrollableFrame::ScrollbarSizesOptions::NONE */)
|
|
const {
|
|
nsRect r = mOuter->GetPaddingRectRelativeToSelf();
|
|
|
|
nsMargin m(mScrollPort.y - r.y, r.XMost() - mScrollPort.XMost(),
|
|
r.YMost() - mScrollPort.YMost(), mScrollPort.x - r.x);
|
|
|
|
if (aOptions == nsIScrollableFrame::ScrollbarSizesOptions::
|
|
INCLUDE_VISUAL_VIEWPORT_SCROLLBARS &&
|
|
!UsesOverlayScrollbars()) {
|
|
// If we are using layout scrollbars and they only exist to scroll the
|
|
// visual viewport then they do not take up any layout space (so the
|
|
// scrollport is the same as the padding rect) but they do cover everything
|
|
// below them so some callers may want to include this special type of
|
|
// scrollbars in the returned value.
|
|
if (mHScrollbarBox && mHasHorizontalScrollbar &&
|
|
mOnlyNeedHScrollbarToScrollVVInsideLV) {
|
|
m.bottom += mHScrollbarBox->GetRect().height;
|
|
}
|
|
if (mVScrollbarBox && mHasVerticalScrollbar &&
|
|
mOnlyNeedVScrollbarToScrollVVInsideLV) {
|
|
if (IsScrollbarOnRight()) {
|
|
m.right += mVScrollbarBox->GetRect().width;
|
|
} else {
|
|
m.left += mVScrollbarBox->GetRect().width;
|
|
}
|
|
}
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
void ScrollFrameHelper::SetScrollbarVisibility(nsIFrame* aScrollbar,
|
|
bool aVisible) {
|
|
nsScrollbarFrame* scrollbar = do_QueryFrame(aScrollbar);
|
|
if (scrollbar) {
|
|
// See if we have a mediator.
|
|
nsIScrollbarMediator* mediator = scrollbar->GetScrollbarMediator();
|
|
if (mediator) {
|
|
// Inform the mediator of the visibility change.
|
|
mediator->VisibilityChanged(aVisible);
|
|
}
|
|
}
|
|
}
|
|
|
|
nscoord ScrollFrameHelper::GetCoordAttribute(nsIFrame* aBox, nsAtom* aAtom,
|
|
nscoord aDefaultValue,
|
|
nscoord* aRangeStart,
|
|
nscoord* aRangeLength) {
|
|
if (aBox) {
|
|
nsIContent* content = aBox->GetContent();
|
|
|
|
nsAutoString value;
|
|
if (content->IsElement()) {
|
|
content->AsElement()->GetAttr(kNameSpaceID_None, aAtom, value);
|
|
}
|
|
if (!value.IsEmpty()) {
|
|
nsresult error;
|
|
// convert it to appunits
|
|
nscoord result =
|
|
nsPresContext::CSSPixelsToAppUnits(value.ToInteger(&error));
|
|
nscoord halfPixel = nsPresContext::CSSPixelsToAppUnits(0.5f);
|
|
// Any nscoord value that would round to the attribute value when
|
|
// converted to CSS pixels is allowed.
|
|
*aRangeStart = result - halfPixel;
|
|
*aRangeLength = halfPixel * 2 - 1;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// Only this exact default value is allowed.
|
|
*aRangeStart = aDefaultValue;
|
|
*aRangeLength = 0;
|
|
return aDefaultValue;
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsLastScrollUpdateAnimating() const {
|
|
if (!mScrollUpdates.IsEmpty()) {
|
|
switch (mScrollUpdates.LastElement().GetMode()) {
|
|
case ScrollMode::Smooth:
|
|
case ScrollMode::SmoothMsd:
|
|
return true;
|
|
case ScrollMode::Instant:
|
|
case ScrollMode::Normal:
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsScrollAnimating(
|
|
IncludeApzAnimation aIncludeApz) const {
|
|
if (aIncludeApz == IncludeApzAnimation::Yes && IsApzAnimationInProgress()) {
|
|
return true;
|
|
}
|
|
if (IsLastScrollUpdateAnimating()) {
|
|
return true;
|
|
}
|
|
return mApzAnimationRequested || mAsyncScroll || mAsyncSmoothMSDScroll;
|
|
}
|
|
|
|
void ScrollFrameHelper::ResetScrollInfoIfNeeded(
|
|
const ScrollGeneration& aGeneration, bool aApzAnimationInProgress) {
|
|
if (aGeneration == mScrollGeneration) {
|
|
mLastScrollOrigin = ScrollOrigin::None;
|
|
mApzAnimationRequested = false;
|
|
}
|
|
// We can reset this regardless of scroll generation, as this is only set
|
|
// here, as a response to APZ requesting a repaint.
|
|
mApzAnimationInProgress = aApzAnimationInProgress;
|
|
}
|
|
|
|
UniquePtr<PresState> ScrollFrameHelper::SaveState() const {
|
|
nsIScrollbarMediator* mediator = do_QueryFrame(GetScrolledFrame());
|
|
if (mediator) {
|
|
// child handles its own scroll state, so don't bother saving state here
|
|
return nullptr;
|
|
}
|
|
|
|
// Don't store a scroll state if we never have been scrolled or restored
|
|
// a previous scroll state, and we're not in the middle of a smooth scroll.
|
|
bool isScrollAnimating = IsScrollAnimating(IncludeApzAnimation::No);
|
|
if (!mHasBeenScrolled && !mDidHistoryRestore && !isScrollAnimating) {
|
|
return nullptr;
|
|
}
|
|
|
|
UniquePtr<PresState> state = NewPresState();
|
|
bool allowScrollOriginDowngrade =
|
|
!nsLayoutUtils::CanScrollOriginClobberApz(mLastScrollOrigin) ||
|
|
mAllowScrollOriginDowngrade;
|
|
// Save mRestorePos instead of our actual current scroll position, if it's
|
|
// valid and we haven't moved since the last update of mLastPos (same check
|
|
// that ScrollToRestoredPosition uses). This ensures if a reframe occurs
|
|
// while we're in the process of loading content to scroll to a restored
|
|
// position, we'll keep trying after the reframe. Similarly, if we're in the
|
|
// middle of a smooth scroll, store the destination so that when we restore
|
|
// we'll jump straight to the end of the scroll animation, rather than
|
|
// effectively dropping it. Note that the mRestorePos will override the
|
|
// smooth scroll destination if both are present.
|
|
nsPoint pt = GetLogicalVisualViewportOffset();
|
|
if (isScrollAnimating) {
|
|
pt = mDestination;
|
|
allowScrollOriginDowngrade = false;
|
|
}
|
|
SCROLLRESTORE_LOG("%p: SaveState, pt=%s, mLastPos=%s, mRestorePos=%s\n", this,
|
|
ToString(pt).c_str(), ToString(mLastPos).c_str(),
|
|
ToString(mRestorePos).c_str());
|
|
if (mRestorePos.y != -1 && pt == mLastPos) {
|
|
pt = mRestorePos;
|
|
}
|
|
state->scrollState() = pt;
|
|
state->allowScrollOriginDowngrade() = allowScrollOriginDowngrade;
|
|
if (mIsRoot) {
|
|
// Only save resolution properties for root scroll frames
|
|
state->resolution() = mOuter->PresShell()->GetResolution();
|
|
}
|
|
return state;
|
|
}
|
|
|
|
void ScrollFrameHelper::RestoreState(PresState* aState) {
|
|
mRestorePos = aState->scrollState();
|
|
MOZ_ASSERT(mLastScrollOrigin == ScrollOrigin::None);
|
|
mAllowScrollOriginDowngrade = aState->allowScrollOriginDowngrade();
|
|
// When restoring state, we promote mLastScrollOrigin to a stronger value
|
|
// from the default of eNone, to restore the behaviour that existed when
|
|
// the state was saved. If mLastScrollOrigin was a weaker value previously,
|
|
// then mAllowScrollOriginDowngrade will be true, and so the combination of
|
|
// mAllowScrollOriginDowngrade and the stronger mLastScrollOrigin will allow
|
|
// the same types of scrolls as before. It might be possible to also just
|
|
// save and restore the mAllowScrollOriginDowngrade and mLastScrollOrigin
|
|
// values directly without this sort of fiddling. Something to try in the
|
|
// future or if we tinker with this code more.
|
|
mLastScrollOrigin = ScrollOrigin::Other;
|
|
mDidHistoryRestore = true;
|
|
mLastPos = mScrolledFrame ? GetLogicalVisualViewportOffset() : nsPoint(0, 0);
|
|
SCROLLRESTORE_LOG("%p: RestoreState, set mRestorePos=%s mLastPos=%s\n", this,
|
|
ToString(mRestorePos).c_str(), ToString(mLastPos).c_str());
|
|
|
|
// Resolution properties should only exist on root scroll frames.
|
|
MOZ_ASSERT(mIsRoot || aState->resolution() == 1.0);
|
|
|
|
if (mIsRoot) {
|
|
mOuter->PresShell()->SetResolutionAndScaleTo(
|
|
aState->resolution(), ResolutionChangeOrigin::MainThreadRestore);
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::PostScrolledAreaEvent() {
|
|
if (mScrolledAreaEvent.IsPending()) {
|
|
return;
|
|
}
|
|
mScrolledAreaEvent = new ScrolledAreaEvent(this);
|
|
nsContentUtils::AddScriptRunner(mScrolledAreaEvent.get());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// ScrolledArea change event dispatch
|
|
|
|
NS_IMETHODIMP
|
|
ScrollFrameHelper::ScrolledAreaEvent::Run() {
|
|
if (mHelper) {
|
|
mHelper->FireScrolledAreaEvent();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void ScrollFrameHelper::FireScrolledAreaEvent() {
|
|
mScrolledAreaEvent.Forget();
|
|
|
|
InternalScrollAreaEvent event(true, eScrolledAreaChanged, nullptr);
|
|
nsPresContext* prescontext = mOuter->PresContext();
|
|
nsIContent* content = mOuter->GetContent();
|
|
|
|
event.mArea = mScrolledFrame->ScrollableOverflowRectRelativeToParent();
|
|
if (Document* doc = content->GetUncomposedDoc()) {
|
|
EventDispatcher::Dispatch(ToSupports(doc), prescontext, &event, nullptr);
|
|
}
|
|
}
|
|
|
|
ScrollDirections nsIScrollableFrame::GetAvailableScrollingDirections() const {
|
|
nscoord oneDevPixel =
|
|
GetScrolledFrame()->PresContext()->AppUnitsPerDevPixel();
|
|
ScrollDirections directions;
|
|
nsRect scrollRange = GetScrollRange();
|
|
if (scrollRange.width >= oneDevPixel) {
|
|
directions += ScrollDirection::eHorizontal;
|
|
}
|
|
if (scrollRange.height >= oneDevPixel) {
|
|
directions += ScrollDirection::eVertical;
|
|
}
|
|
return directions;
|
|
}
|
|
|
|
nsRect ScrollFrameHelper::GetScrollRangeForUserInputEvents() const {
|
|
// This function computes a scroll range based on a scrolled rect and scroll
|
|
// port defined as follows:
|
|
// scrollable rect = overflow:hidden ? layout viewport : scrollable rect
|
|
// scroll port = have visual viewport ? visual viewport : layout viewport
|
|
// The results in the same notion of scroll range that APZ uses (the combined
|
|
// effect of FrameMetrics::CalculateScrollRange() and
|
|
// nsLayoutUtils::CalculateScrollableRectForFrame).
|
|
|
|
ScrollStyles ss = GetScrollStylesFromFrame();
|
|
|
|
nsPoint scrollPos = GetScrollPosition();
|
|
|
|
nsRect scrolledRect = GetScrolledRect();
|
|
if (StyleOverflow::Hidden == ss.mHorizontal) {
|
|
scrolledRect.width = mScrollPort.width;
|
|
scrolledRect.x = scrollPos.x;
|
|
}
|
|
if (StyleOverflow::Hidden == ss.mVertical) {
|
|
scrolledRect.height = mScrollPort.height;
|
|
scrolledRect.y = scrollPos.y;
|
|
}
|
|
|
|
nsSize scrollPort = GetVisualViewportSize();
|
|
|
|
nsRect scrollRange = scrolledRect;
|
|
scrollRange.width = std::max(scrolledRect.width - scrollPort.width, 0);
|
|
scrollRange.height = std::max(scrolledRect.height - scrollPort.height, 0);
|
|
|
|
return scrollRange;
|
|
}
|
|
|
|
ScrollDirections
|
|
ScrollFrameHelper::GetAvailableScrollingDirectionsForUserInputEvents() const {
|
|
nsRect scrollRange = GetScrollRangeForUserInputEvents();
|
|
|
|
// We check if there is at least one half of a screen pixel of scroll range to
|
|
// roughly match what apz does when it checks if the change in scroll position
|
|
// in screen pixels round to zero or not.
|
|
// (https://searchfox.org/mozilla-central/rev/2f09184ec781a2667feec87499d4b81b32b6c48e/gfx/layers/apz/src/AsyncPanZoomController.cpp#3210)
|
|
// This isn't quite half a screen pixel, it doesn't take into account CSS
|
|
// transforms, but should be good enough.
|
|
float halfScreenPixel =
|
|
GetScrolledFrame()->PresContext()->AppUnitsPerDevPixel() /
|
|
(mOuter->PresShell()->GetCumulativeResolution() * 2.f);
|
|
ScrollDirections directions;
|
|
if (scrollRange.width >= halfScreenPixel) {
|
|
directions += ScrollDirection::eHorizontal;
|
|
}
|
|
if (scrollRange.height >= halfScreenPixel) {
|
|
directions += ScrollDirection::eVertical;
|
|
}
|
|
return directions;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* Append scroll positions for valid snap positions into |aSnapInfo| if
|
|
* applicable.
|
|
*/
|
|
static void AppendScrollPositionsForSnap(const nsIFrame* aFrame,
|
|
const nsIFrame* aScrolledFrame,
|
|
const nsRect& aScrolledRect,
|
|
const nsMargin& aScrollPadding,
|
|
const Maybe<nsRect>& aSnapport,
|
|
WritingMode aWritingModeOnScroller,
|
|
ScrollSnapInfo& aSnapInfo) {
|
|
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();
|
|
nsRect snapArea =
|
|
InflateByScrollMargin(targetRect, scrollMargin, aScrolledRect);
|
|
|
|
// Ignore elements outside of the snapport when we scroll to the given
|
|
// destination.
|
|
// https://drafts.csswg.org/css-scroll-snap-1/#snap-scope
|
|
if (aSnapport && !aSnapport->Intersects(snapArea)) {
|
|
return;
|
|
}
|
|
|
|
// These snap range shouldn't be involved with scroll-margin since we just
|
|
// need the visible range of the target element.
|
|
if (snapArea.width > aSnapInfo.mSnapportSize.width) {
|
|
aSnapInfo.mXRangeWiderThanSnapport.AppendElement(
|
|
ScrollSnapInfo::ScrollSnapRange(snapArea.X(), snapArea.XMost()));
|
|
}
|
|
if (snapArea.height > aSnapInfo.mSnapportSize.height) {
|
|
aSnapInfo.mYRangeWiderThanSnapport.AppendElement(
|
|
ScrollSnapInfo::ScrollSnapRange(snapArea.Y(), snapArea.YMost()));
|
|
}
|
|
|
|
// Shift target rect position by the scroll padding to get the padded
|
|
// position thus we don't need to take account scroll-padding values in
|
|
// ScrollSnapUtils::GetSnapPointForDestination() when it gets called from
|
|
// the compositor thread.
|
|
snapArea.y -= aScrollPadding.top;
|
|
snapArea.x -= aScrollPadding.left;
|
|
|
|
LogicalRect logicalTargetRect(aWritingModeOnScroller, snapArea,
|
|
aSnapInfo.mSnapportSize);
|
|
LogicalSize logicalSnapportRect(aWritingModeOnScroller,
|
|
aSnapInfo.mSnapportSize);
|
|
|
|
Maybe<nscoord> blockDirectionPosition;
|
|
Maybe<nscoord> inlineDirectionPosition;
|
|
|
|
const nsStyleDisplay* styleDisplay = aFrame->StyleDisplay();
|
|
nscoord containerBSize = logicalSnapportRect.BSize(aWritingModeOnScroller);
|
|
switch (styleDisplay->mScrollSnapAlign.block) {
|
|
case StyleScrollSnapAlignKeyword::None:
|
|
break;
|
|
case StyleScrollSnapAlignKeyword::Start:
|
|
blockDirectionPosition.emplace(
|
|
aWritingModeOnScroller.IsVerticalRL()
|
|
? -logicalTargetRect.BStart(aWritingModeOnScroller)
|
|
: logicalTargetRect.BStart(aWritingModeOnScroller));
|
|
break;
|
|
case StyleScrollSnapAlignKeyword::End:
|
|
if (aWritingModeOnScroller.IsVerticalRL()) {
|
|
blockDirectionPosition.emplace(
|
|
containerBSize - logicalTargetRect.BEnd(aWritingModeOnScroller));
|
|
} else {
|
|
// What we need here is the scroll position instead of the snap position
|
|
// itself, so we need, for example, the top edge of the scroll port
|
|
// on horizontal-tb when the frame is positioned at the bottom edge of
|
|
// the scroll port. For this reason we subtract containerBSize from
|
|
// BEnd of the target.
|
|
blockDirectionPosition.emplace(
|
|
logicalTargetRect.BEnd(aWritingModeOnScroller) - containerBSize);
|
|
}
|
|
break;
|
|
case StyleScrollSnapAlignKeyword::Center: {
|
|
nscoord targetCenter = (logicalTargetRect.BStart(aWritingModeOnScroller) +
|
|
logicalTargetRect.BEnd(aWritingModeOnScroller)) /
|
|
2;
|
|
nscoord halfSnapportSize = containerBSize / 2;
|
|
// Get the center of the target to align with the center of the snapport
|
|
// depending on direction.
|
|
if (aWritingModeOnScroller.IsVerticalRL()) {
|
|
blockDirectionPosition.emplace(halfSnapportSize - targetCenter);
|
|
} else {
|
|
blockDirectionPosition.emplace(targetCenter - halfSnapportSize);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
nscoord containerISize = logicalSnapportRect.ISize(aWritingModeOnScroller);
|
|
switch (styleDisplay->mScrollSnapAlign.inline_) {
|
|
case StyleScrollSnapAlignKeyword::None:
|
|
break;
|
|
case StyleScrollSnapAlignKeyword::Start:
|
|
inlineDirectionPosition.emplace(
|
|
aWritingModeOnScroller.IsInlineReversed()
|
|
? -logicalTargetRect.IStart(aWritingModeOnScroller)
|
|
: logicalTargetRect.IStart(aWritingModeOnScroller));
|
|
break;
|
|
case StyleScrollSnapAlignKeyword::End:
|
|
if (aWritingModeOnScroller.IsInlineReversed()) {
|
|
inlineDirectionPosition.emplace(
|
|
containerISize - logicalTargetRect.IEnd(aWritingModeOnScroller));
|
|
} else {
|
|
// Same as above BEnd case, we subtract containerISize.
|
|
inlineDirectionPosition.emplace(
|
|
logicalTargetRect.IEnd(aWritingModeOnScroller) - containerISize);
|
|
}
|
|
break;
|
|
case StyleScrollSnapAlignKeyword::Center: {
|
|
nscoord targetCenter = (logicalTargetRect.IStart(aWritingModeOnScroller) +
|
|
logicalTargetRect.IEnd(aWritingModeOnScroller)) /
|
|
2;
|
|
nscoord halfSnapportSize = containerISize / 2;
|
|
// Get the center of the target to align with the center of the snapport
|
|
// depending on direction.
|
|
if (aWritingModeOnScroller.IsInlineReversed()) {
|
|
inlineDirectionPosition.emplace(halfSnapportSize - targetCenter);
|
|
} else {
|
|
inlineDirectionPosition.emplace(targetCenter - halfSnapportSize);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (inlineDirectionPosition) {
|
|
(aWritingModeOnScroller.IsVertical() ? aSnapInfo.mSnapPositionY
|
|
: aSnapInfo.mSnapPositionX)
|
|
.AppendElement(inlineDirectionPosition.value());
|
|
}
|
|
|
|
if (blockDirectionPosition) {
|
|
(aWritingModeOnScroller.IsVertical() ? aSnapInfo.mSnapPositionX
|
|
: aSnapInfo.mSnapPositionY)
|
|
.AppendElement(blockDirectionPosition.value());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Collect the scroll positions corresponding to snap positions of frames in the
|
|
* subtree rooted at |aFrame|, relative to |aScrolledFrame|, into |aSnapInfo|.
|
|
* If |aSnapport| is given, elements outside of the range of |aSnapport| will be
|
|
* ignored.
|
|
*/
|
|
static void CollectScrollPositionsForSnap(
|
|
nsIFrame* aFrame, nsIFrame* aScrolledFrame, const nsRect& aScrolledRect,
|
|
const nsMargin& aScrollPadding, const Maybe<nsRect>& aSnapport,
|
|
WritingMode aWritingModeOnScroller, ScrollSnapInfo& aSnapInfo) {
|
|
// Snap positions only affect the nearest ancestor scroll container on the
|
|
// element's containing block chain.
|
|
nsIScrollableFrame* sf = do_QueryFrame(aFrame);
|
|
if (sf) {
|
|
return;
|
|
}
|
|
|
|
for (const auto& childList : aFrame->ChildLists()) {
|
|
for (nsIFrame* f : childList.mList) {
|
|
const nsStyleDisplay* styleDisplay = f->StyleDisplay();
|
|
if (styleDisplay->mScrollSnapAlign.inline_ !=
|
|
StyleScrollSnapAlignKeyword::None ||
|
|
styleDisplay->mScrollSnapAlign.block !=
|
|
StyleScrollSnapAlignKeyword::None) {
|
|
AppendScrollPositionsForSnap(f, aScrolledFrame, aScrolledRect,
|
|
aScrollPadding, aSnapport,
|
|
aWritingModeOnScroller, aSnapInfo);
|
|
}
|
|
CollectScrollPositionsForSnap(f, aScrolledFrame, aScrolledRect,
|
|
aScrollPadding, aSnapport,
|
|
aWritingModeOnScroller, aSnapInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
static nscoord ResolveScrollPaddingStyleValue(
|
|
const StyleRect<mozilla::NonNegativeLengthPercentageOrAuto>&
|
|
aScrollPaddingStyle,
|
|
Side aSide, const nsSize& aScrollPortSize) {
|
|
if (aScrollPaddingStyle.Get(aSide).IsAuto()) {
|
|
// https://drafts.csswg.org/css-scroll-snap-1/#valdef-scroll-padding-auto
|
|
return 0;
|
|
}
|
|
|
|
nscoord percentageBasis;
|
|
switch (aSide) {
|
|
case eSideTop:
|
|
case eSideBottom:
|
|
percentageBasis = aScrollPortSize.height;
|
|
break;
|
|
case eSideLeft:
|
|
case eSideRight:
|
|
percentageBasis = aScrollPortSize.width;
|
|
break;
|
|
}
|
|
|
|
return aScrollPaddingStyle.Get(aSide).AsLengthPercentage().Resolve(
|
|
percentageBasis);
|
|
}
|
|
|
|
static nsMargin ResolveScrollPaddingStyle(
|
|
const StyleRect<mozilla::NonNegativeLengthPercentageOrAuto>&
|
|
aScrollPaddingStyle,
|
|
const nsSize& aScrollPortSize) {
|
|
return nsMargin(ResolveScrollPaddingStyleValue(aScrollPaddingStyle, eSideTop,
|
|
aScrollPortSize),
|
|
ResolveScrollPaddingStyleValue(aScrollPaddingStyle,
|
|
eSideRight, aScrollPortSize),
|
|
ResolveScrollPaddingStyleValue(aScrollPaddingStyle,
|
|
eSideBottom, aScrollPortSize),
|
|
ResolveScrollPaddingStyleValue(aScrollPaddingStyle, eSideLeft,
|
|
aScrollPortSize));
|
|
}
|
|
|
|
nsMargin ScrollFrameHelper::GetScrollPadding() const {
|
|
nsIFrame* styleFrame = GetFrameForStyle();
|
|
if (!styleFrame) {
|
|
return nsMargin();
|
|
}
|
|
|
|
// The spec says percentage values are relative to the scroll port size.
|
|
// https://drafts.csswg.org/css-scroll-snap-1/#scroll-padding
|
|
return ResolveScrollPaddingStyle(styleFrame->StylePadding()->mScrollPadding,
|
|
GetScrollPortRect().Size());
|
|
}
|
|
|
|
layers::ScrollSnapInfo ScrollFrameHelper::ComputeScrollSnapInfo(
|
|
const Maybe<nsPoint>& aDestination) const {
|
|
ScrollSnapInfo result;
|
|
|
|
nsIFrame* scrollSnapFrame = GetFrameForStyle();
|
|
if (!scrollSnapFrame) {
|
|
return result;
|
|
}
|
|
|
|
const nsStyleDisplay* disp = scrollSnapFrame->StyleDisplay();
|
|
if (disp->mScrollSnapType.strictness == StyleScrollSnapStrictness::None) {
|
|
// We won't be snapping, short-circuit the computation.
|
|
return result;
|
|
}
|
|
|
|
WritingMode writingMode = mOuter->GetWritingMode();
|
|
result.InitializeScrollSnapStrictness(writingMode, disp);
|
|
|
|
nsRect snapport = GetScrollPortRect();
|
|
nsMargin scrollPadding = GetScrollPadding();
|
|
|
|
Maybe<nsRect> snapportOnDestination;
|
|
if (aDestination) {
|
|
snapport.MoveTo(aDestination.value());
|
|
snapport.Deflate(scrollPadding);
|
|
snapportOnDestination.emplace(snapport);
|
|
} else {
|
|
snapport.Deflate(scrollPadding);
|
|
}
|
|
|
|
result.mSnapportSize = snapport.Size();
|
|
CollectScrollPositionsForSnap(mScrolledFrame, mScrolledFrame,
|
|
GetScrolledRect(), scrollPadding,
|
|
snapportOnDestination, writingMode, result);
|
|
return result;
|
|
}
|
|
|
|
layers::ScrollSnapInfo ScrollFrameHelper::GetScrollSnapInfo(
|
|
const Maybe<nsPoint>& aDestination) const {
|
|
// TODO(botond): Should we cache it?
|
|
return ComputeScrollSnapInfo(aDestination);
|
|
}
|
|
|
|
bool ScrollFrameHelper::GetSnapPointForDestination(ScrollUnit aUnit,
|
|
const nsPoint& aStartPos,
|
|
nsPoint& aDestination) {
|
|
Maybe<nsPoint> snapPoint = ScrollSnapUtils::GetSnapPointForDestination(
|
|
GetScrollSnapInfo(Some(aDestination)), aUnit, GetLayoutScrollRange(),
|
|
aStartPos, aDestination);
|
|
if (snapPoint) {
|
|
aDestination = snapPoint.ref();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ScrollFrameHelper::UsesOverlayScrollbars() const {
|
|
return Document::UseOverlayScrollbars(mOuter->PresShell()->GetDocument());
|
|
}
|
|
|
|
bool ScrollFrameHelper::DragScroll(WidgetEvent* aEvent) {
|
|
// Dragging is allowed while within a 20 pixel border. Note that device pixels
|
|
// are used so that the same margin is used even when zoomed in or out.
|
|
nscoord margin = 20 * mOuter->PresContext()->AppUnitsPerDevPixel();
|
|
|
|
// Don't drag scroll for small scrollareas.
|
|
if (mScrollPort.width < margin * 2 || mScrollPort.height < margin * 2) {
|
|
return false;
|
|
}
|
|
|
|
// If willScroll is computed as false, then the frame is already scrolled as
|
|
// far as it can go in both directions. Return false so that an ancestor
|
|
// scrollframe can scroll instead.
|
|
bool willScroll = false;
|
|
nsPoint pnt =
|
|
nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, RelativeTo{mOuter});
|
|
nsPoint scrollPoint = GetScrollPosition();
|
|
nsRect rangeRect = GetLayoutScrollRange();
|
|
|
|
// Only drag scroll when a scrollbar is present.
|
|
nsPoint offset;
|
|
if (mHasHorizontalScrollbar) {
|
|
if (pnt.x >= mScrollPort.x && pnt.x <= mScrollPort.x + margin) {
|
|
offset.x = -margin;
|
|
if (scrollPoint.x > 0) {
|
|
willScroll = true;
|
|
}
|
|
} else if (pnt.x >= mScrollPort.XMost() - margin &&
|
|
pnt.x <= mScrollPort.XMost()) {
|
|
offset.x = margin;
|
|
if (scrollPoint.x < rangeRect.width) {
|
|
willScroll = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mHasVerticalScrollbar) {
|
|
if (pnt.y >= mScrollPort.y && pnt.y <= mScrollPort.y + margin) {
|
|
offset.y = -margin;
|
|
if (scrollPoint.y > 0) {
|
|
willScroll = true;
|
|
}
|
|
} else if (pnt.y >= mScrollPort.YMost() - margin &&
|
|
pnt.y <= mScrollPort.YMost()) {
|
|
offset.y = margin;
|
|
if (scrollPoint.y < rangeRect.height) {
|
|
willScroll = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (offset.x || offset.y) {
|
|
ScrollTo(GetScrollPosition() + offset, ScrollMode::Normal,
|
|
ScrollOrigin::Other);
|
|
}
|
|
|
|
return willScroll;
|
|
}
|
|
|
|
static nsSliderFrame* GetSliderFrame(nsIFrame* aScrollbarFrame) {
|
|
if (!aScrollbarFrame) {
|
|
return nullptr;
|
|
}
|
|
|
|
for (const auto& childList : aScrollbarFrame->ChildLists()) {
|
|
for (nsIFrame* frame : childList.mList) {
|
|
if (nsSliderFrame* sliderFrame = do_QueryFrame(frame)) {
|
|
return sliderFrame;
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static void AsyncScrollbarDragInitiated(uint64_t aDragBlockId,
|
|
nsIFrame* aScrollbar) {
|
|
if (nsSliderFrame* sliderFrame = GetSliderFrame(aScrollbar)) {
|
|
sliderFrame->AsyncScrollbarDragInitiated(aDragBlockId);
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::AsyncScrollbarDragInitiated(
|
|
uint64_t aDragBlockId, ScrollDirection aDirection) {
|
|
switch (aDirection) {
|
|
case ScrollDirection::eVertical:
|
|
::AsyncScrollbarDragInitiated(aDragBlockId, mVScrollbarBox);
|
|
break;
|
|
case ScrollDirection::eHorizontal:
|
|
::AsyncScrollbarDragInitiated(aDragBlockId, mHScrollbarBox);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void AsyncScrollbarDragRejected(nsIFrame* aScrollbar) {
|
|
if (nsSliderFrame* sliderFrame = GetSliderFrame(aScrollbar)) {
|
|
sliderFrame->AsyncScrollbarDragRejected();
|
|
}
|
|
}
|
|
|
|
void ScrollFrameHelper::AsyncScrollbarDragRejected() {
|
|
// We don't get told which scrollbar requested the async drag,
|
|
// so we notify both.
|
|
::AsyncScrollbarDragRejected(mHScrollbarBox);
|
|
::AsyncScrollbarDragRejected(mVScrollbarBox);
|
|
}
|
|
|
|
void ScrollFrameHelper::ApzSmoothScrollTo(const nsPoint& aDestination,
|
|
ScrollOrigin aOrigin) {
|
|
if (mApzSmoothScrollDestination == Some(aDestination)) {
|
|
// If we already sent APZ a smooth-scroll request to this
|
|
// destination (i.e. it was the last request
|
|
// we sent), then don't send another one because it is redundant.
|
|
// This is to avoid a scenario where pages do repeated scrollBy
|
|
// calls, incrementing the generation counter, and blocking APZ from
|
|
// syncing the scroll offset back to the main thread.
|
|
// Note that if we get two smooth-scroll requests to the same
|
|
// destination with some other scroll in between,
|
|
// mApzSmoothScrollDestination will get reset to Nothing() and so
|
|
// we shouldn't have the problem where this check discards a
|
|
// legitimate smooth-scroll.
|
|
return;
|
|
}
|
|
|
|
// The animation will be handled in the compositor, pass the
|
|
// information needed to start the animation and skip the main-thread
|
|
// animation for this scroll.
|
|
MOZ_ASSERT(aOrigin != ScrollOrigin::None);
|
|
mApzSmoothScrollDestination = Some(aDestination);
|
|
AppendScrollUpdate(
|
|
ScrollPositionUpdate::NewSmoothScroll(aOrigin, aDestination));
|
|
|
|
nsIContent* content = mOuter->GetContent();
|
|
if (!DisplayPortUtils::HasNonMinimalNonZeroDisplayPort(content)) {
|
|
// If this frame doesn't have a displayport then there won't be an
|
|
// APZC instance for it and so there won't be anything to process
|
|
// this smooth scroll request. We should set a displayport on this
|
|
// frame to force an APZC which can handle the request.
|
|
if (MOZ_LOG_TEST(sDisplayportLog, LogLevel::Debug)) {
|
|
mozilla::layers::ScrollableLayerGuid::ViewID viewID =
|
|
mozilla::layers::ScrollableLayerGuid::NULL_SCROLL_ID;
|
|
nsLayoutUtils::FindIDFor(content, &viewID);
|
|
MOZ_LOG(
|
|
sDisplayportLog, LogLevel::Debug,
|
|
("ApzSmoothScrollTo setting displayport on scrollId=%" PRIu64 "\n",
|
|
viewID));
|
|
}
|
|
|
|
DisplayPortUtils::CalculateAndSetDisplayPortMargins(
|
|
mOuter->GetScrollTargetFrame(), DisplayPortUtils::RepaintMode::Repaint);
|
|
nsIFrame* frame = do_QueryFrame(mOuter->GetScrollTargetFrame());
|
|
DisplayPortUtils::SetZeroMarginDisplayPortOnAsyncScrollableAncestors(frame);
|
|
}
|
|
|
|
// Schedule a paint to ensure that the frame metrics get updated on
|
|
// the compositor thread.
|
|
mOuter->SchedulePaint();
|
|
}
|
|
|
|
bool ScrollFrameHelper::SmoothScrollVisual(
|
|
const nsPoint& aVisualViewportOffset,
|
|
FrameMetrics::ScrollOffsetUpdateType aUpdateType) {
|
|
bool canDoApzSmoothScroll =
|
|
StaticPrefs::layout_css_scroll_behavior_enabled() &&
|
|
nsLayoutUtils::AsyncPanZoomEnabled(mOuter) && WantAsyncScroll();
|
|
if (!canDoApzSmoothScroll) {
|
|
return false;
|
|
}
|
|
|
|
// Clamp the destination to the visual scroll range.
|
|
// There is a potential issue here, where |mDestination| is usually
|
|
// clamped to the layout scroll range, and so e.g. a subsequent
|
|
// window.scrollBy() may have an undesired effect. However, as this function
|
|
// is only called internally, this should not be a problem in practice.
|
|
// If it turns out to be, the fix would be:
|
|
// - add a new "destination" field that doesn't have to be clamped to
|
|
// the layout scroll range
|
|
// - clamp mDestination to the layout scroll range here
|
|
// - make sure ComputeScrollMetadata() picks up the former as the
|
|
// smooth scroll destination to send to APZ.
|
|
mDestination = GetVisualScrollRange().ClampPoint(aVisualViewportOffset);
|
|
|
|
// Perform the scroll.
|
|
ApzSmoothScrollTo(mDestination, aUpdateType == FrameMetrics::eRestore
|
|
? ScrollOrigin::Restore
|
|
: ScrollOrigin::Other);
|
|
return true;
|
|
}
|
|
|
|
bool ScrollFrameHelper::IsSmoothScroll(dom::ScrollBehavior aBehavior) const {
|
|
if (aBehavior == dom::ScrollBehavior::Smooth) {
|
|
return true;
|
|
}
|
|
|
|
nsIFrame* styleFrame = GetFrameForStyle();
|
|
if (!styleFrame) {
|
|
return false;
|
|
}
|
|
return (aBehavior == dom::ScrollBehavior::Auto &&
|
|
styleFrame->StyleDisplay()->mScrollBehavior ==
|
|
StyleScrollBehavior::Smooth);
|
|
}
|
|
|
|
nsTArray<ScrollPositionUpdate> ScrollFrameHelper::GetScrollUpdates() const {
|
|
return mScrollUpdates.Clone();
|
|
}
|
|
|
|
void ScrollFrameHelper::AppendScrollUpdate(
|
|
const ScrollPositionUpdate& aUpdate) {
|
|
mScrollGeneration = aUpdate.GetGeneration();
|
|
mScrollUpdates.AppendElement(aUpdate);
|
|
}
|