From 0e6a9cc60aeb754e00e466ce20052d2fa9ccb7f9 Mon Sep 17 00:00:00 2001 From: Moonchild Date: Wed, 6 Jan 2021 16:31:36 +0000 Subject: Issue #1705 - Part 3: Rename ScrollbarStyles to ScrollStyles. ScrollbarStyles contains values of overflow, (over)scroll-behavior, etc. The only one which is marginally related to scroll _bars_ is overflow, which can be used to hide scrollbar (by making an element not scrollable) or enforce the scrollbar to display. It makes more sense to be called ScrollStyles as it's mainly concerning behavior of scrolling, not scrollbars. Also, with the addition of scrollbar width properties, the current name can be confusing. --- layout/base/RestyleManagerBase.cpp | 4 +- layout/base/ScrollStyles.cpp | 32 ++++++++++++++ layout/base/ScrollStyles.h | 82 +++++++++++++++++++++++++++++++++++ layout/base/ScrollbarStyles.cpp | 32 -------------- layout/base/ScrollbarStyles.h | 82 ----------------------------------- layout/base/moz.build | 4 +- layout/base/nsCSSFrameConstructor.cpp | 10 ++--- layout/base/nsCSSFrameConstructor.h | 2 +- layout/base/nsLayoutUtils.cpp | 8 ++-- layout/base/nsPresContext.cpp | 28 ++++++------ layout/base/nsPresContext.h | 18 ++++---- layout/base/nsPresShell.cpp | 4 +- layout/forms/nsListControlFrame.cpp | 10 ++--- layout/forms/nsListControlFrame.h | 2 +- layout/generic/TextOverflow.cpp | 4 +- layout/generic/nsFrame.cpp | 2 +- layout/generic/nsGfxScrollFrame.cpp | 34 +++++++-------- layout/generic/nsGfxScrollFrame.h | 10 ++--- layout/generic/nsIScrollableFrame.h | 4 +- layout/style/nsRuleNode.cpp | 2 +- layout/xul/nsListBoxBodyFrame.cpp | 4 +- 21 files changed, 189 insertions(+), 189 deletions(-) create mode 100644 layout/base/ScrollStyles.cpp create mode 100644 layout/base/ScrollStyles.h delete mode 100644 layout/base/ScrollbarStyles.cpp delete mode 100644 layout/base/ScrollbarStyles.h (limited to 'layout') diff --git a/layout/base/RestyleManagerBase.cpp b/layout/base/RestyleManagerBase.cpp index 433589dac..192c0df99 100644 --- a/layout/base/RestyleManagerBase.cpp +++ b/layout/base/RestyleManagerBase.cpp @@ -1137,9 +1137,9 @@ if (!mDestroyedFrames) { // to reconstruct - we can just reflow, because no scrollframe is being // added/removed. nsIContent* prevOverrideNode = - presContext->GetViewportScrollbarStylesOverrideNode(); + presContext->GetViewportScrollStylesOverrideNode(); nsIContent* newOverrideNode = - presContext->UpdateViewportScrollbarStylesOverride(); + presContext->UpdateViewportScrollStylesOverride(); if (data.mContent == prevOverrideNode || data.mContent == newOverrideNode) { diff --git a/layout/base/ScrollStyles.cpp b/layout/base/ScrollStyles.cpp new file mode 100644 index 000000000..328657d3d --- /dev/null +++ b/layout/base/ScrollStyles.cpp @@ -0,0 +1,32 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "ScrollStyles.h" +#include "nsStyleStruct.h" // for nsStyleDisplay and nsStyleBackground::Position + +namespace mozilla { + + ScrollStyles::ScrollStyles(uint8_t aH, uint8_t aV, + const nsStyleDisplay* aDisplay) + : mHorizontal(aH), mVertical(aV), + mScrollBehavior(aDisplay->mScrollBehavior), + mScrollSnapTypeX(aDisplay->mScrollSnapTypeX), + mScrollSnapTypeY(aDisplay->mScrollSnapTypeY), + mScrollSnapPointsX(aDisplay->mScrollSnapPointsX), + mScrollSnapPointsY(aDisplay->mScrollSnapPointsY), + mScrollSnapDestinationX(aDisplay->mScrollSnapDestination.mXPosition), + mScrollSnapDestinationY(aDisplay->mScrollSnapDestination.mYPosition) {} + + ScrollStyles::ScrollStyles(const nsStyleDisplay* aDisplay) + : mHorizontal(aDisplay->mOverflowX), mVertical(aDisplay->mOverflowY), + mScrollBehavior(aDisplay->mScrollBehavior), + mScrollSnapTypeX(aDisplay->mScrollSnapTypeX), + mScrollSnapTypeY(aDisplay->mScrollSnapTypeY), + mScrollSnapPointsX(aDisplay->mScrollSnapPointsX), + mScrollSnapPointsY(aDisplay->mScrollSnapPointsY), + mScrollSnapDestinationX(aDisplay->mScrollSnapDestination.mXPosition), + mScrollSnapDestinationY(aDisplay->mScrollSnapDestination.mYPosition) {} + +} // namespace mozilla diff --git a/layout/base/ScrollStyles.h b/layout/base/ScrollStyles.h new file mode 100644 index 000000000..c5743ee6b --- /dev/null +++ b/layout/base/ScrollStyles.h @@ -0,0 +1,82 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef ScrollStyles_h +#define ScrollStyles_h + +#include +#include "nsStyleConsts.h" // for NS_STYLE_SCROLL_SNAP_* +#include "nsStyleCoord.h" // for nsStyleCoord +#include "mozilla/dom/WindowBinding.h" + +// Forward declarations +struct nsStyleDisplay; + +namespace mozilla { + +struct ScrollStyles +{ + // Always one of NS_STYLE_OVERFLOW_SCROLL, NS_STYLE_OVERFLOW_HIDDEN, + // or NS_STYLE_OVERFLOW_AUTO. + uint8_t mHorizontal; + uint8_t mVertical; + // Always one of NS_STYLE_SCROLL_BEHAVIOR_AUTO or + // NS_STYLE_SCROLL_BEHAVIOR_SMOOTH + uint8_t mScrollBehavior; + // Always one of NS_STYLE_SCROLL_SNAP_NONE, NS_STYLE_SCROLL_SNAP_MANDATORY, + // or NS_STYLE_SCROLL_SNAP_PROXIMITY. + uint8_t mScrollSnapTypeX; + uint8_t mScrollSnapTypeY; + nsStyleCoord mScrollSnapPointsX; + nsStyleCoord mScrollSnapPointsY; + nsStyleCoord::CalcValue mScrollSnapDestinationX; + nsStyleCoord::CalcValue mScrollSnapDestinationY; + + ScrollStyles(uint8_t aH, uint8_t aV) + : mHorizontal(aH), mVertical(aV), + mScrollBehavior(NS_STYLE_SCROLL_BEHAVIOR_AUTO), + mScrollSnapTypeX(NS_STYLE_SCROLL_SNAP_TYPE_NONE), + mScrollSnapTypeY(NS_STYLE_SCROLL_SNAP_TYPE_NONE), + mScrollSnapPointsX(nsStyleCoord(eStyleUnit_None)), + mScrollSnapPointsY(nsStyleCoord(eStyleUnit_None)) { + + mScrollSnapDestinationX.mPercent = 0; + mScrollSnapDestinationX.mLength = nscoord(0.0f); + mScrollSnapDestinationX.mHasPercent = false; + mScrollSnapDestinationY.mPercent = 0; + mScrollSnapDestinationY.mLength = nscoord(0.0f); + mScrollSnapDestinationY.mHasPercent = false; + } + + explicit ScrollStyles(const nsStyleDisplay* aDisplay); + ScrollStyles(uint8_t aH, uint8_t aV, const nsStyleDisplay* aDisplay); + ScrollStyles() {} + bool operator==(const ScrollStyles& aStyles) const { + return aStyles.mHorizontal == mHorizontal && aStyles.mVertical == mVertical && + aStyles.mScrollBehavior == mScrollBehavior && + aStyles.mScrollSnapTypeX == mScrollSnapTypeX && + aStyles.mScrollSnapTypeY == mScrollSnapTypeY && + aStyles.mScrollSnapPointsX == mScrollSnapPointsX && + aStyles.mScrollSnapPointsY == mScrollSnapPointsY && + aStyles.mScrollSnapDestinationX == mScrollSnapDestinationX && + aStyles.mScrollSnapDestinationY == mScrollSnapDestinationY; + } + bool operator!=(const ScrollStyles& aStyles) const { + return !(*this == aStyles); + } + bool IsHiddenInBothDirections() const { + return mHorizontal == NS_STYLE_OVERFLOW_HIDDEN && + mVertical == NS_STYLE_OVERFLOW_HIDDEN; + } + bool IsSmoothScroll(dom::ScrollBehavior aBehavior) const { + return aBehavior == dom::ScrollBehavior::Smooth || + (aBehavior == dom::ScrollBehavior::Auto && + mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH); + } +}; + +} // namespace mozilla + +#endif diff --git a/layout/base/ScrollbarStyles.cpp b/layout/base/ScrollbarStyles.cpp deleted file mode 100644 index cc9f0c57d..000000000 --- a/layout/base/ScrollbarStyles.cpp +++ /dev/null @@ -1,32 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ - -#include "ScrollbarStyles.h" -#include "nsStyleStruct.h" // for nsStyleDisplay and nsStyleBackground::Position - -namespace mozilla { - - ScrollbarStyles::ScrollbarStyles(uint8_t aH, uint8_t aV, - const nsStyleDisplay* aDisplay) - : mHorizontal(aH), mVertical(aV), - mScrollBehavior(aDisplay->mScrollBehavior), - mScrollSnapTypeX(aDisplay->mScrollSnapTypeX), - mScrollSnapTypeY(aDisplay->mScrollSnapTypeY), - mScrollSnapPointsX(aDisplay->mScrollSnapPointsX), - mScrollSnapPointsY(aDisplay->mScrollSnapPointsY), - mScrollSnapDestinationX(aDisplay->mScrollSnapDestination.mXPosition), - mScrollSnapDestinationY(aDisplay->mScrollSnapDestination.mYPosition) {} - - ScrollbarStyles::ScrollbarStyles(const nsStyleDisplay* aDisplay) - : mHorizontal(aDisplay->mOverflowX), mVertical(aDisplay->mOverflowY), - mScrollBehavior(aDisplay->mScrollBehavior), - mScrollSnapTypeX(aDisplay->mScrollSnapTypeX), - mScrollSnapTypeY(aDisplay->mScrollSnapTypeY), - mScrollSnapPointsX(aDisplay->mScrollSnapPointsX), - mScrollSnapPointsY(aDisplay->mScrollSnapPointsY), - mScrollSnapDestinationX(aDisplay->mScrollSnapDestination.mXPosition), - mScrollSnapDestinationY(aDisplay->mScrollSnapDestination.mYPosition) {} - -} // namespace mozilla diff --git a/layout/base/ScrollbarStyles.h b/layout/base/ScrollbarStyles.h deleted file mode 100644 index e6f0c6dde..000000000 --- a/layout/base/ScrollbarStyles.h +++ /dev/null @@ -1,82 +0,0 @@ -/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ - -#ifndef ScrollbarStyles_h -#define ScrollbarStyles_h - -#include -#include "nsStyleConsts.h" // for NS_STYLE_SCROLL_SNAP_* -#include "nsStyleCoord.h" // for nsStyleCoord -#include "mozilla/dom/WindowBinding.h" - -// Forward declarations -struct nsStyleDisplay; - -namespace mozilla { - -struct ScrollbarStyles -{ - // Always one of NS_STYLE_OVERFLOW_SCROLL, NS_STYLE_OVERFLOW_HIDDEN, - // or NS_STYLE_OVERFLOW_AUTO. - uint8_t mHorizontal; - uint8_t mVertical; - // Always one of NS_STYLE_SCROLL_BEHAVIOR_AUTO or - // NS_STYLE_SCROLL_BEHAVIOR_SMOOTH - uint8_t mScrollBehavior; - // Always one of NS_STYLE_SCROLL_SNAP_NONE, NS_STYLE_SCROLL_SNAP_MANDATORY, - // or NS_STYLE_SCROLL_SNAP_PROXIMITY. - uint8_t mScrollSnapTypeX; - uint8_t mScrollSnapTypeY; - nsStyleCoord mScrollSnapPointsX; - nsStyleCoord mScrollSnapPointsY; - nsStyleCoord::CalcValue mScrollSnapDestinationX; - nsStyleCoord::CalcValue mScrollSnapDestinationY; - - ScrollbarStyles(uint8_t aH, uint8_t aV) - : mHorizontal(aH), mVertical(aV), - mScrollBehavior(NS_STYLE_SCROLL_BEHAVIOR_AUTO), - mScrollSnapTypeX(NS_STYLE_SCROLL_SNAP_TYPE_NONE), - mScrollSnapTypeY(NS_STYLE_SCROLL_SNAP_TYPE_NONE), - mScrollSnapPointsX(nsStyleCoord(eStyleUnit_None)), - mScrollSnapPointsY(nsStyleCoord(eStyleUnit_None)) { - - mScrollSnapDestinationX.mPercent = 0; - mScrollSnapDestinationX.mLength = nscoord(0.0f); - mScrollSnapDestinationX.mHasPercent = false; - mScrollSnapDestinationY.mPercent = 0; - mScrollSnapDestinationY.mLength = nscoord(0.0f); - mScrollSnapDestinationY.mHasPercent = false; - } - - explicit ScrollbarStyles(const nsStyleDisplay* aDisplay); - ScrollbarStyles(uint8_t aH, uint8_t aV, const nsStyleDisplay* aDisplay); - ScrollbarStyles() {} - bool operator==(const ScrollbarStyles& aStyles) const { - return aStyles.mHorizontal == mHorizontal && aStyles.mVertical == mVertical && - aStyles.mScrollBehavior == mScrollBehavior && - aStyles.mScrollSnapTypeX == mScrollSnapTypeX && - aStyles.mScrollSnapTypeY == mScrollSnapTypeY && - aStyles.mScrollSnapPointsX == mScrollSnapPointsX && - aStyles.mScrollSnapPointsY == mScrollSnapPointsY && - aStyles.mScrollSnapDestinationX == mScrollSnapDestinationX && - aStyles.mScrollSnapDestinationY == mScrollSnapDestinationY; - } - bool operator!=(const ScrollbarStyles& aStyles) const { - return !(*this == aStyles); - } - bool IsHiddenInBothDirections() const { - return mHorizontal == NS_STYLE_OVERFLOW_HIDDEN && - mVertical == NS_STYLE_OVERFLOW_HIDDEN; - } - bool IsSmoothScroll(dom::ScrollBehavior aBehavior) const { - return aBehavior == dom::ScrollBehavior::Smooth || - (aBehavior == dom::ScrollBehavior::Auto && - mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH); - } -}; - -} // namespace mozilla - -#endif diff --git a/layout/base/moz.build b/layout/base/moz.build index 51cab4c6b..86377e9db 100644 --- a/layout/base/moz.build +++ b/layout/base/moz.build @@ -95,7 +95,7 @@ EXPORTS += [ 'nsRefreshDriver.h', 'nsStyleChangeList.h', 'nsStyleSheetService.h', - 'ScrollbarStyles.h', + 'ScrollStyles.h', 'StackArena.h', 'Units.h', 'UnitTransforms.h', @@ -162,7 +162,7 @@ SOURCES += [ 'RestyleManager.cpp', 'RestyleManagerBase.cpp', 'RestyleTracker.cpp', - 'ScrollbarStyles.cpp', + 'ScrollStyles.cpp', 'ServoRestyleManager.cpp', 'StackArena.cpp', 'StaticPresData.cpp', diff --git a/layout/base/nsCSSFrameConstructor.cpp b/layout/base/nsCSSFrameConstructor.cpp index 45b95826c..2cc5ec818 100644 --- a/layout/base/nsCSSFrameConstructor.cpp +++ b/layout/base/nsCSSFrameConstructor.cpp @@ -2406,12 +2406,12 @@ nsCSSFrameConstructor::ConstructDocElementFrame(Element* aDocEle GetRootFrame()->SetStyleContextWithoutNotification(sc); } - // Make sure to call UpdateViewportScrollbarStylesOverride before + // Make sure to call UpdateViewportScrollStylesOverride before // SetUpDocElementContainingBlock, since it sets up our scrollbar state // properly. DebugOnly propagatedScrollFrom; if (nsPresContext* presContext = mPresShell->GetPresContext()) { - propagatedScrollFrom = presContext->UpdateViewportScrollbarStylesOverride(); + propagatedScrollFrom = presContext->UpdateViewportScrollStylesOverride(); } SetUpDocElementContainingBlock(aDocElement); @@ -4660,7 +4660,7 @@ nsCSSFrameConstructor::FindDisplayData(const nsStyleDisplay* aDisplay, if (aElement->IsHTMLElement(nsGkAtoms::body)) { if (nsPresContext* presContext = mPresShell->GetPresContext()) { propagatedScrollToViewport = - presContext->UpdateViewportScrollbarStylesOverride() == aElement; + presContext->UpdateViewportScrollStylesOverride() == aElement; } } @@ -4696,7 +4696,7 @@ nsCSSFrameConstructor::FindDisplayData(const nsStyleDisplay* aDisplay, // scrollframe so that it paginates correctly, but we don't want to set // the bit on the block that tells it to clip at paint time. if (mPresShell->GetPresContext()-> - ElementWouldPropagateScrollbarStyles(aElement)) { + ElementWouldPropagateScrollStyles(aElement)) { suppressScrollFrame = false; } } @@ -8133,7 +8133,7 @@ nsCSSFrameConstructor::ContentRemoved(nsIContent* aContainer, // source is a fullscreen element, and we have code elsewhere to update // scrollbars after fullscreen elements are removed -- specifically, it's // part of the fullscreen cleanup code called by Element::UnbindFromTree.) - presContext->UpdateViewportScrollbarStylesOverride(); + presContext->UpdateViewportScrollStylesOverride(); } // XXXldb Do we need to re-resolve style to handle the CSS2 + combinator and diff --git a/layout/base/nsCSSFrameConstructor.h b/layout/base/nsCSSFrameConstructor.h index 0de00a90c..abdfbf7ce 100644 --- a/layout/base/nsCSSFrameConstructor.h +++ b/layout/base/nsCSSFrameConstructor.h @@ -22,7 +22,7 @@ #include "nsCounterManager.h" #include "nsIAnonymousContentCreator.h" #include "nsFrameManager.h" -#include "ScrollbarStyles.h" +#include "ScrollStyles.h" struct nsFrameItems; class nsStyleContext; diff --git a/layout/base/nsLayoutUtils.cpp b/layout/base/nsLayoutUtils.cpp index 86a11bce9..ccdc5503f 100644 --- a/layout/base/nsLayoutUtils.cpp +++ b/layout/base/nsLayoutUtils.cpp @@ -2023,7 +2023,7 @@ nsLayoutUtils::GetNearestScrollableFrameForDirection(nsIFrame* aFrame, for (nsIFrame* f = aFrame; f; f = nsLayoutUtils::GetCrossDocParentFrame(f)) { nsIScrollableFrame* scrollableFrame = do_QueryFrame(f); if (scrollableFrame) { - ScrollbarStyles ss = scrollableFrame->GetScrollbarStyles(); + ScrollStyles ss = scrollableFrame->GetScrollStyles(); uint32_t directions = scrollableFrame->GetPerceivedScrollingDirections(); if (aDirection == eVertical ? (ss.mVertical != NS_STYLE_OVERFLOW_HIDDEN && @@ -2050,7 +2050,7 @@ nsLayoutUtils::GetNearestScrollableFrame(nsIFrame* aFrame, uint32_t aFlags) return scrollableFrame; } } else { - ScrollbarStyles ss = scrollableFrame->GetScrollbarStyles(); + ScrollStyles ss = scrollableFrame->GetScrollStyles(); if ((aFlags & SCROLLABLE_INCLUDE_HIDDEN) || ss.mVertical != NS_STYLE_OVERFLOW_HIDDEN || ss.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN) { @@ -8255,11 +8255,11 @@ nsLayoutUtils::CalculateScrollableRectForFrame(nsIScrollableFrame* aScrollableFr contentBounds = aScrollableFrame->GetScrollRange(); nsPoint scrollPosition = aScrollableFrame->GetScrollPosition(); - if (aScrollableFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_HIDDEN) { + if (aScrollableFrame->GetScrollStyles().mVertical == NS_STYLE_OVERFLOW_HIDDEN) { contentBounds.y = scrollPosition.y; contentBounds.height = 0; } - if (aScrollableFrame->GetScrollbarStyles().mHorizontal == NS_STYLE_OVERFLOW_HIDDEN) { + if (aScrollableFrame->GetScrollStyles().mHorizontal == NS_STYLE_OVERFLOW_HIDDEN) { contentBounds.x = scrollPosition.x; contentBounds.width = 0; } diff --git a/layout/base/nsPresContext.cpp b/layout/base/nsPresContext.cpp index 1d90b967a..f7be42b5f 100644 --- a/layout/base/nsPresContext.cpp +++ b/layout/base/nsPresContext.cpp @@ -1346,7 +1346,7 @@ nsPresContext::ScreenSizeInchesForFontInflation(bool* aChanged) } static bool -CheckOverflow(const nsStyleDisplay* aDisplay, ScrollbarStyles* aStyles) +CheckOverflow(const nsStyleDisplay* aDisplay, ScrollStyles* aStyles) { if (aDisplay->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE && aDisplay->mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_AUTO && @@ -1362,17 +1362,17 @@ CheckOverflow(const nsStyleDisplay* aDisplay, ScrollbarStyles* aStyles) } if (aDisplay->mOverflowX == NS_STYLE_OVERFLOW_CLIP) { - *aStyles = ScrollbarStyles(NS_STYLE_OVERFLOW_HIDDEN, + *aStyles = ScrollStyles(NS_STYLE_OVERFLOW_HIDDEN, NS_STYLE_OVERFLOW_HIDDEN, aDisplay); } else { - *aStyles = ScrollbarStyles(aDisplay); + *aStyles = ScrollStyles(aDisplay); } return true; } static nsIContent* -GetPropagatedScrollbarStylesForViewport(nsPresContext* aPresContext, - ScrollbarStyles *aStyles) +GetPropagatedScrollStylesForViewport(nsPresContext* aPresContext, + ScrollStyles *aStyles) { nsIDocument* document = aPresContext->Document(); Element* docElement = document->GetRootElement(); @@ -1424,16 +1424,16 @@ GetPropagatedScrollbarStylesForViewport(nsPresContext* aPresContext, } nsIContent* -nsPresContext::UpdateViewportScrollbarStylesOverride() +nsPresContext::UpdateViewportScrollStylesOverride() { // Start off with our default styles, and then update them as needed. - mViewportStyleScrollbar = ScrollbarStyles(NS_STYLE_OVERFLOW_AUTO, + mViewportStyleScrollbar = ScrollStyles(NS_STYLE_OVERFLOW_AUTO, NS_STYLE_OVERFLOW_AUTO); mViewportScrollbarOverrideNode = nullptr; // Don't propagate the scrollbar state in printing or print preview. if (!IsPaginated()) { mViewportScrollbarOverrideNode = - GetPropagatedScrollbarStylesForViewport(this, &mViewportStyleScrollbar); + GetPropagatedScrollStylesForViewport(this, &mViewportStyleScrollbar); } nsIDocument* document = Document(); @@ -1445,7 +1445,7 @@ nsPresContext::UpdateViewportScrollbarStylesOverride() // affected across fullscreen change. if (fullscreenElement != document->GetRootElement() && fullscreenElement != mViewportScrollbarOverrideNode) { - mViewportStyleScrollbar = ScrollbarStyles(NS_STYLE_OVERFLOW_HIDDEN, + mViewportStyleScrollbar = ScrollStyles(NS_STYLE_OVERFLOW_HIDDEN, NS_STYLE_OVERFLOW_HIDDEN); } } @@ -1454,7 +1454,7 @@ nsPresContext::UpdateViewportScrollbarStylesOverride() } bool -nsPresContext::ElementWouldPropagateScrollbarStyles(Element* aElement) +nsPresContext::ElementWouldPropagateScrollStyles(Element* aElement) { MOZ_ASSERT(IsPaginated(), "Should only be called on paginated contexts"); if (aElement->GetParent() && !aElement->IsHTMLElement(nsGkAtoms::body)) { @@ -1462,13 +1462,13 @@ nsPresContext::ElementWouldPropagateScrollbarStyles(Element* aElement) return false; } - // Go ahead and just call GetPropagatedScrollbarStylesForViewport, but update - // a dummy ScrollbarStyles we don't care about. It'll do a bit of extra work, + // Go ahead and just call GetPropagatedScrollStylesForViewport, but update + // a dummy ScrollStyles we don't care about. It'll do a bit of extra work, // but saves us having to have more complicated code or more code duplication; // in practice we will make this call quite rarely, because we checked for all // the common cases above. - ScrollbarStyles dummy(NS_STYLE_OVERFLOW_AUTO, NS_STYLE_OVERFLOW_AUTO); - return GetPropagatedScrollbarStylesForViewport(this, &dummy) == aElement; + ScrollStyles dummy(NS_STYLE_OVERFLOW_AUTO, NS_STYLE_OVERFLOW_AUTO); + return GetPropagatedScrollStylesForViewport(this, &dummy) == aElement; } void diff --git a/layout/base/nsPresContext.h b/layout/base/nsPresContext.h index a2b9bb533..10908a604 100644 --- a/layout/base/nsPresContext.h +++ b/layout/base/nsPresContext.h @@ -35,7 +35,7 @@ #include "mozilla/AppUnits.h" #include "prclist.h" #include "nsThreadUtils.h" -#include "ScrollbarStyles.h" +#include "ScrollStyles.h" #include "nsIMessageManager.h" #include "mozilla/RestyleLogging.h" #include "Units.h" @@ -140,7 +140,7 @@ class nsPresContext : public nsIObserver, public mozilla::SupportsWeakPtr { public: typedef mozilla::LangGroupFontPrefs LangGroupFontPrefs; - typedef mozilla::ScrollbarStyles ScrollbarStyles; + typedef mozilla::ScrollStyles ScrollStyles; typedef mozilla::StaticPresData StaticPresData; NS_DECL_CYCLE_COLLECTING_ISUPPORTS @@ -716,19 +716,19 @@ public: * @return if scroll was propagated from some content node, the content node * it was propagated from. */ - nsIContent* UpdateViewportScrollbarStylesOverride(); + nsIContent* UpdateViewportScrollStylesOverride(); /** * Returns the cached result from the last call to - * UpdateViewportScrollbarStylesOverride() -- i.e. return the node + * UpdateViewportScrollStylesOverride() -- i.e. return the node * whose scrollbar styles we have propagated to the viewport (or nullptr if * there is no such node). */ - nsIContent* GetViewportScrollbarStylesOverrideNode() const { + nsIContent* GetViewportScrollStylesOverrideNode() const { return mViewportScrollbarOverrideNode; } - const ScrollbarStyles& GetViewportScrollbarStylesOverride() const + const ScrollStyles& GetViewportScrollStylesOverride() const { return mViewportStyleScrollbar; } @@ -737,7 +737,7 @@ public: * Check whether the given element would propagate its scrollbar styles to the * viewport in non-paginated mode. Must only be called if IsPaginated(). */ - bool ElementWouldPropagateScrollbarStyles(mozilla::dom::Element* aElement); + bool ElementWouldPropagateScrollStyles(mozilla::dom::Element* aElement); /** * Set and get methods for controlling the background drawing @@ -1312,13 +1312,13 @@ protected: // This is a non-owning pointer. May be null. If non-null, it's guaranteed // to be pointing to a node that's still alive, because we'll reset it in - // UpdateViewportScrollbarStylesOverride() as part of the cleanup code + // UpdateViewportScrollStylesOverride() as part of the cleanup code // when this node is removed from the document. (For and the root node, // this call happens in nsCSSFrameConstructor::ContentRemoved(). For // fullscreen elements, it happens in the fullscreen-specific cleanup // invoked by Element::UnbindFromTree().) nsIContent* MOZ_NON_OWNING_REF mViewportScrollbarOverrideNode; - ScrollbarStyles mViewportStyleScrollbar; + ScrollStyles mViewportStyleScrollbar; uint8_t mFocusRingWidth; diff --git a/layout/base/nsPresShell.cpp b/layout/base/nsPresShell.cpp index 1fb223172..9ba4ff462 100644 --- a/layout/base/nsPresShell.cpp +++ b/layout/base/nsPresShell.cpp @@ -3331,7 +3331,7 @@ static void ScrollToShowRect(nsIScrollableFrame* aFrameAsScrollable, aHorizontal.mWhenToScroll == nsIPresShell::SCROLL_IF_NOT_VISIBLE) { lineSize = aFrameAsScrollable->GetLineScrollAmount(); } - ScrollbarStyles ss = aFrameAsScrollable->GetScrollbarStyles(); + ScrollStyles ss = aFrameAsScrollable->GetScrollStyles(); nsRect allowedRange(scrollPt, nsSize(0, 0)); bool needToScroll = false; uint32_t directions = aFrameAsScrollable->GetPerceivedScrollingDirections(); @@ -3388,7 +3388,7 @@ static void ScrollToShowRect(nsIScrollableFrame* aFrameAsScrollable, // a current smooth scroll operation. if (needToScroll) { nsIScrollableFrame::ScrollMode scrollMode = nsIScrollableFrame::INSTANT; - bool autoBehaviorIsSmooth = (aFrameAsScrollable->GetScrollbarStyles().mScrollBehavior + bool autoBehaviorIsSmooth = (aFrameAsScrollable->GetScrollStyles().mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH); bool smoothScroll = (aFlags & nsIPresShell::SCROLL_SMOOTH) || ((aFlags & nsIPresShell::SCROLL_SMOOTH_AUTO) && autoBehaviorIsSmooth); diff --git a/layout/forms/nsListControlFrame.cpp b/layout/forms/nsListControlFrame.cpp index 7bd356a22..4daa470a9 100644 --- a/layout/forms/nsListControlFrame.cpp +++ b/layout/forms/nsListControlFrame.cpp @@ -614,17 +614,17 @@ nsListControlFrame::ReflowAsDropdown(nsPresContext* aPresContext, nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus); } -ScrollbarStyles -nsListControlFrame::GetScrollbarStyles() const +ScrollStyles +nsListControlFrame::GetScrollStyles() const { // We can't express this in the style system yet; when we can, this can go away - // and GetScrollbarStyles can be devirtualized + // and GetScrollStyles can be devirtualized int32_t style = IsInDropDownMode() ? NS_STYLE_OVERFLOW_AUTO : NS_STYLE_OVERFLOW_SCROLL; if (GetWritingMode().IsVertical()) { - return ScrollbarStyles(style, NS_STYLE_OVERFLOW_HIDDEN); + return ScrollStyles(style, NS_STYLE_OVERFLOW_HIDDEN); } else { - return ScrollbarStyles(NS_STYLE_OVERFLOW_HIDDEN, style); + return ScrollStyles(NS_STYLE_OVERFLOW_HIDDEN, style); } } diff --git a/layout/forms/nsListControlFrame.h b/layout/forms/nsListControlFrame.h index d8df9ebd6..fa939d6c8 100644 --- a/layout/forms/nsListControlFrame.h +++ b/layout/forms/nsListControlFrame.h @@ -106,7 +106,7 @@ public: virtual nsresult SetFormProperty(nsIAtom* aName, const nsAString& aValue) override; virtual void SetFocus(bool aOn = true, bool aRepaint = false) override; - virtual mozilla::ScrollbarStyles GetScrollbarStyles() const override; + virtual mozilla::ScrollStyles GetScrollStyles() const override; virtual bool ShouldPropagateComputedBSizeToScrolledContent() const override; // for accessibility purposes diff --git a/layout/generic/TextOverflow.cpp b/layout/generic/TextOverflow.cpp index f4db27766..3d78eaf91 100644 --- a/layout/generic/TextOverflow.cpp +++ b/layout/generic/TextOverflow.cpp @@ -305,8 +305,8 @@ TextOverflow::TextOverflow(nsDisplayListBuilder* aBuilder, mCanHaveInlineAxisScrollbar = false; if (mScrollableFrame) { auto scrollbarStyle = mBlockWM.IsVertical() ? - mScrollableFrame->GetScrollbarStyles().mVertical : - mScrollableFrame->GetScrollbarStyles().mHorizontal; + mScrollableFrame->GetScrollStyles().mVertical : + mScrollableFrame->GetScrollStyles().mHorizontal; mCanHaveInlineAxisScrollbar = scrollbarStyle != NS_STYLE_OVERFLOW_HIDDEN; if (!mAdjustForPixelSnapping) { // Scrolling to the end position can leave some text still overflowing due diff --git a/layout/generic/nsFrame.cpp b/layout/generic/nsFrame.cpp index a9e6354ab..5d05b7103 100644 --- a/layout/generic/nsFrame.cpp +++ b/layout/generic/nsFrame.cpp @@ -9188,7 +9188,7 @@ nsIFrame::IsFocusable(int32_t *aTabIndex, bool aWithMouse) // will be enough to make them keyboard scrollable. nsIScrollableFrame *scrollFrame = do_QueryFrame(this); if (scrollFrame && - !scrollFrame->GetScrollbarStyles().IsHiddenInBothDirections() && + !scrollFrame->GetScrollStyles().IsHiddenInBothDirections() && !scrollFrame->GetScrollRange().IsEqualEdges(nsRect(0, 0, 0, 0))) { // Scroll bars will be used for overflow isFocusable = true; diff --git a/layout/generic/nsGfxScrollFrame.cpp b/layout/generic/nsGfxScrollFrame.cpp index 95e4b9bf4..8e7b208e4 100644 --- a/layout/generic/nsGfxScrollFrame.cpp +++ b/layout/generic/nsGfxScrollFrame.cpp @@ -263,7 +263,7 @@ struct MOZ_STACK_CLASS ScrollReflowInput { // worry about the reflow depth here , mBoxState(aState.mFrame->PresContext(), aState.mRenderingContext, 0) { - ScrollbarStyles styles = aFrame->GetScrollbarStyles(); + ScrollStyles styles = aFrame->GetScrollStyles(); mHScrollbar = ShouldShowScrollbar(styles.mHorizontal); mVScrollbar = ShouldShowScrollbar(styles.mVertical); } @@ -808,7 +808,7 @@ nsHTMLScrollFrame::PlaceScrollArea(ScrollReflowInput& aState, nscoord nsHTMLScrollFrame::GetIntrinsicVScrollbarWidth(nsRenderingContext *aRenderingContext) { - ScrollbarStyles ss = GetScrollbarStyles(); + ScrollStyles ss = GetScrollStyles(); if (ss.mVertical != NS_STYLE_OVERFLOW_SCROLL || !mHelper.mVScrollbarBox) return 0; @@ -1161,7 +1161,7 @@ nsHTMLScrollFrame::AccessibleType() // 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() || - GetScrollbarStyles().IsHiddenInBothDirections()) { + GetScrollStyles().IsHiddenInBothDirections()) { return a11y::eNoType; } @@ -1320,7 +1320,7 @@ ScrollFrameHelper::WantAsyncScroll() const return true; } - ScrollbarStyles styles = GetScrollbarStylesFromFrame(); + ScrollStyles styles = GetScrollStylesFromFrame(); nscoord oneDevPixel = GetScrolledFrame()->PresContext()->AppUnitsPerDevPixel(); nsRect scrollRange = GetScrollRange(); bool isVScrollable = (scrollRange.height >= oneDevPixel) && @@ -1571,7 +1571,7 @@ nsXULScrollFrame::GetXULPrefSize(nsBoxLayoutState& aState) nsSize pref = mHelper.mScrolledFrame->GetXULPrefSize(aState); - ScrollbarStyles styles = GetScrollbarStyles(); + ScrollStyles styles = GetScrollStyles(); // scrolled frames don't have their own margins @@ -1604,7 +1604,7 @@ nsXULScrollFrame::GetXULMinSize(nsBoxLayoutState& aState) nsSize min = mHelper.mScrolledFrame->GetXULMinSizeForScrollArea(aState); - ScrollbarStyles styles = GetScrollbarStyles(); + ScrollStyles styles = GetScrollStyles(); if (mHelper.mVScrollbarBox && styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) { @@ -2490,7 +2490,7 @@ bool ScrollFrameHelper::IsAlwaysActive() const // If we're overflow:hidden, then start as inactive until // we get scrolled manually. - ScrollbarStyles styles = GetScrollbarStylesFromFrame(); + ScrollStyles styles = GetScrollStylesFromFrame(); return (styles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN && styles.mVertical != NS_STYLE_OVERFLOW_HIDDEN); } @@ -3821,21 +3821,21 @@ static void HandleScrollPref(nsIScrollable *aScrollable, int32_t aOrientation, } } -ScrollbarStyles -ScrollFrameHelper::GetScrollbarStylesFromFrame() const +ScrollStyles +ScrollFrameHelper::GetScrollStylesFromFrame() const { nsPresContext* presContext = mOuter->PresContext(); if (!presContext->IsDynamic() && !(mIsRoot && presContext->HasPaginatedScrolling())) { - return ScrollbarStyles(NS_STYLE_OVERFLOW_HIDDEN, NS_STYLE_OVERFLOW_HIDDEN); + return ScrollStyles(NS_STYLE_OVERFLOW_HIDDEN, NS_STYLE_OVERFLOW_HIDDEN); } if (!mIsRoot) { const nsStyleDisplay* disp = mOuter->StyleDisplay(); - return ScrollbarStyles(disp); + return ScrollStyles(disp); } - ScrollbarStyles result = presContext->GetViewportScrollbarStylesOverride(); + ScrollStyles result = presContext->GetViewportScrollStylesOverride(); nsCOMPtr container = presContext->GetContainerWeak(); nsCOMPtr scrollable = do_QueryInterface(container); if (scrollable) { @@ -4004,7 +4004,7 @@ ScrollFrameHelper::ScrollBy(nsIntPoint aDelta, nsPoint newPos = mDestination + nsPoint(aDelta.x*deltaMultiplier.width, aDelta.y*deltaMultiplier.height); if (aSnap == nsIScrollableFrame::ENABLE_SNAP) { - ScrollbarStyles styles = GetScrollbarStylesFromFrame(); + ScrollStyles styles = GetScrollStylesFromFrame(); if (styles.mScrollSnapTypeY != NS_STYLE_SCROLL_SNAP_TYPE_NONE || styles.mScrollSnapTypeX != NS_STYLE_SCROLL_SNAP_TYPE_NONE) { nscoord appUnitsPerDevPixel = mOuter->PresContext()->AppUnitsPerDevPixel(); @@ -4412,7 +4412,7 @@ ScrollFrameHelper::CreateAnonymousContent( bool canHaveHorizontal; bool canHaveVertical; if (!mIsRoot) { - ScrollbarStyles styles = scrollable->GetScrollbarStyles(); + ScrollStyles styles = scrollable->GetScrollStyles(); canHaveHorizontal = styles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN; canHaveVertical = styles.mVertical != NS_STYLE_OVERFLOW_HIDDEN; if (!canHaveHorizontal && !canHaveVertical && !isResizable) { @@ -5094,7 +5094,7 @@ nsXULScrollFrame::XULLayout(nsBoxLayoutState& aState) (if we're the viewport and we added or removed a scrollbar). **************/ - ScrollbarStyles styles = GetScrollbarStyles(); + ScrollStyles styles = GetScrollStyles(); // Look at our style do we always have vertical or horizontal scrollbars? if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) @@ -5399,7 +5399,7 @@ bool ScrollFrameHelper::ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) { nsIScrollableFrame* sf = do_QueryFrame(mOuter); - ScrollbarStyles ss = sf->GetScrollbarStyles(); + 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 @@ -6121,7 +6121,7 @@ ComputeScrollSnapInfo(const ScrollFrameHelper& aScrollFrame) { ScrollSnapInfo result; - ScrollbarStyles styles = aScrollFrame.GetScrollbarStylesFromFrame(); + ScrollStyles styles = aScrollFrame.GetScrollStylesFromFrame(); if (styles.mScrollSnapTypeY == NS_STYLE_SCROLL_SNAP_TYPE_NONE && styles.mScrollSnapTypeX == NS_STYLE_SCROLL_SNAP_TYPE_NONE) { diff --git a/layout/generic/nsGfxScrollFrame.h b/layout/generic/nsGfxScrollFrame.h index 296867856..41957d5e5 100644 --- a/layout/generic/nsGfxScrollFrame.h +++ b/layout/generic/nsGfxScrollFrame.h @@ -55,7 +55,7 @@ public: ScrollFrameHelper(nsContainerFrame* aOuter, bool aIsRoot); ~ScrollFrameHelper(); - mozilla::ScrollbarStyles GetScrollbarStylesFromFrame() const; + mozilla::ScrollStyles GetScrollStylesFromFrame() const; // If a child frame was added or removed on the scrollframe, // reload our child frame list. @@ -775,8 +775,8 @@ public: virtual nsIFrame* GetScrolledFrame() const override { return mHelper.GetScrolledFrame(); } - virtual mozilla::ScrollbarStyles GetScrollbarStyles() const override { - return mHelper.GetScrollbarStylesFromFrame(); + virtual mozilla::ScrollStyles GetScrollStyles() const override { + return mHelper.GetScrollStylesFromFrame(); } virtual uint32_t GetScrollbarVisibility() const override { return mHelper.GetScrollbarVisibility(); @@ -1199,8 +1199,8 @@ public: virtual nsIFrame* GetScrolledFrame() const override { return mHelper.GetScrolledFrame(); } - virtual mozilla::ScrollbarStyles GetScrollbarStyles() const override { - return mHelper.GetScrollbarStylesFromFrame(); + virtual mozilla::ScrollStyles GetScrollStyles() const override { + return mHelper.GetScrollStylesFromFrame(); } virtual uint32_t GetScrollbarVisibility() const override { return mHelper.GetScrollbarVisibility(); diff --git a/layout/generic/nsIScrollableFrame.h b/layout/generic/nsIScrollableFrame.h index b7e3caf46..4ad45a528 100644 --- a/layout/generic/nsIScrollableFrame.h +++ b/layout/generic/nsIScrollableFrame.h @@ -12,7 +12,7 @@ #include "nsCoord.h" #include "DisplayItemClip.h" -#include "ScrollbarStyles.h" +#include "ScrollStyles.h" #include "mozilla/Maybe.h" #include "mozilla/gfx/Point.h" #include "nsIScrollbarMediator.h" @@ -63,7 +63,7 @@ public: * or NS_STYLE_OVERFLOW_AUTO) governing the horizontal and vertical * scrollbars for this frame. */ - virtual mozilla::ScrollbarStyles GetScrollbarStyles() const = 0; + virtual mozilla::ScrollStyles GetScrollStyles() const = 0; enum { HORIZONTAL = 0x01, VERTICAL = 0x02 }; /** diff --git a/layout/style/nsRuleNode.cpp b/layout/style/nsRuleNode.cpp index 9721b4bed..504b66ac2 100644 --- a/layout/style/nsRuleNode.cpp +++ b/layout/style/nsRuleNode.cpp @@ -424,7 +424,7 @@ static nsSize CalcViewportUnitsScale(nsPresContext* aPresContext) nsIScrollableFrame* scrollFrame = aPresContext->PresShell()->GetRootScrollFrameAsScrollable(); if (scrollFrame) { - ScrollbarStyles styles(scrollFrame->GetScrollbarStyles()); + ScrollStyles styles(scrollFrame->GetScrollStyles()); if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL || styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) { diff --git a/layout/xul/nsListBoxBodyFrame.cpp b/layout/xul/nsListBoxBodyFrame.cpp index 8c4a5e2fd..0ff07bd91 100644 --- a/layout/xul/nsListBoxBodyFrame.cpp +++ b/layout/xul/nsListBoxBodyFrame.cpp @@ -296,7 +296,7 @@ nsListBoxBodyFrame::GetXULMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState result.height = 0; nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); if (scrollFrame && - scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) { + scrollFrame->GetScrollStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) { nsMargin scrollbars = scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState); result.width += scrollbars.left + scrollbars.right; @@ -316,7 +316,7 @@ nsListBoxBodyFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); if (scrollFrame && - scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) { + scrollFrame->GetScrollStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) { nsMargin scrollbars = scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState); pref.width += scrollbars.left + scrollbars.right; } -- cgit v1.2.3