Update game ScrollContainer usage in line with framework changes

peppy · peppy · commit 94ea003d90f0 · 2025-01-11T01:42:59.000+09:00
See ppy/osu-framework#6467.
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneSectionsContainer.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneSectionsContainer.cs
@@ -138,7 +138,7 @@ void step(int scrollIndex)
                 AddUntilStep("section top is visible", () =>
                 {
                     var scrollContainer = container.ChildrenOfType<UserTrackingScrollContainer>().Single();
-                    float sectionPosition = scrollContainer.GetChildPosInContent(container.Children[scrollIndex]);
+                    double sectionPosition = scrollContainer.GetChildPosInContent(container.Children[scrollIndex]);
                     return scrollContainer.Current < sectionPosition;
                 });
             }
diff --git a/osu.Game/Graphics/Containers/OsuScrollContainer.cs b/osu.Game/Graphics/Containers/OsuScrollContainer.cs
@@ -59,11 +59,11 @@ public OsuScrollContainer(Direction scrollDirection = Direction.Vertical)
         /// <param name="extraScroll">An added amount to scroll beyond the requirement to bring the target into view.</param>
         public void ScrollIntoView(Drawable d, bool animated = true, float extraScroll = 0)
         {
-            float childPos0 = GetChildPosInContent(d);
-            float childPos1 = GetChildPosInContent(d, d.DrawSize);
+            double childPos0 = GetChildPosInContent(d);
+            double childPos1 = GetChildPosInContent(d, d.DrawSize);
 
-            float minPos = Math.Min(childPos0, childPos1);
-            float maxPos = Math.Max(childPos0, childPos1);
+            double minPos = Math.Min(childPos0, childPos1);
+            double maxPos = Math.Max(childPos0, childPos1);
 
             if (minPos < Current || (minPos > Current && d.DrawSize[ScrollDim] > DisplayableContent))
                 ScrollTo(minPos - extraScroll, animated);
diff --git a/osu.Game/Graphics/Containers/SectionsContainer.cs b/osu.Game/Graphics/Containers/SectionsContainer.cs
@@ -208,7 +208,7 @@ public void ScrollTo(Drawable target)
         private float getScrollTargetForDrawable(Drawable target)
         {
             // implementation similar to ScrollIntoView but a bit more nuanced.
-            return scrollContainer.GetChildPosInContent(target) - scrollContainer.DisplayableContent * scroll_y_centre;
+            return (float)(scrollContainer.GetChildPosInContent(target) - scrollContainer.DisplayableContent * scroll_y_centre);
         }
 
         public void ScrollToTop() => scrollContainer.ScrollTo(0);
@@ -259,7 +259,7 @@ protected override void UpdateAfterChildren()
                 updateSectionsMargin();
             }
 
-            float currentScroll = scrollContainer.Current;
+            float currentScroll = (float)scrollContainer.Current;
 
             if (currentScroll != lastKnownScroll)
             {
diff --git a/osu.Game/Graphics/Containers/UserTrackingScrollContainer.cs b/osu.Game/Graphics/Containers/UserTrackingScrollContainer.cs
@@ -35,7 +35,7 @@ public UserTrackingScrollContainer(Direction direction)
         {
         }
 
-        protected override void OnUserScroll(float value, bool animated = true, double? distanceDecay = default)
+        protected override void OnUserScroll(double value, bool animated = true, double? distanceDecay = default)
         {
             UserScrolling = true;
             base.OnUserScroll(value, animated, distanceDecay);
@@ -53,7 +53,7 @@ protected override void ScrollFromMouseEvent(MouseEvent e)
             base.ScrollFromMouseEvent(e);
         }
 
-        public new void ScrollTo(float value, bool animated = true, double? distanceDecay = null)
+        public new void ScrollTo(double value, bool animated = true, double? distanceDecay = null)
         {
             UserScrolling = false;
             base.ScrollTo(value, animated, distanceDecay);
diff --git a/osu.Game/Online/Leaderboards/Leaderboard.cs b/osu.Game/Online/Leaderboards/Leaderboard.cs
@@ -375,8 +375,8 @@ protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
 
-            float fadeBottom = scrollContainer.Current + scrollContainer.DrawHeight;
-            float fadeTop = scrollContainer.Current + LeaderboardScore.HEIGHT;
+            float fadeBottom = (float)(scrollContainer.Current + scrollContainer.DrawHeight);
+            float fadeTop = (float)(scrollContainer.Current + LeaderboardScore.HEIGHT);
 
             if (!scrollContainer.IsScrolledToEnd())
                 fadeBottom -= LeaderboardScore.HEIGHT;
diff --git a/osu.Game/Overlays/Chat/ChannelScrollContainer.cs b/osu.Game/Overlays/Chat/ChannelScrollContainer.cs
@@ -41,13 +41,13 @@ protected override void UpdateAfterChildren()
 
         #region Scroll handling
 
-        protected override void OnUserScroll(float value, bool animated = true, double? distanceDecay = null)
+        protected override void OnUserScroll(double value, bool animated = true, double? distanceDecay = null)
         {
             base.OnUserScroll(value, animated, distanceDecay);
             updateTrackState();
         }
 
-        public new void ScrollTo(float value, bool animated = true, double? distanceDecay = null)
+        public new void ScrollTo(double value, bool animated = true, double? distanceDecay = null)
         {
             base.ScrollTo(value, animated, distanceDecay);
             updateTrackState();
diff --git a/osu.Game/Overlays/Chat/DrawableChannel.cs b/osu.Game/Overlays/Chat/DrawableChannel.cs
@@ -117,7 +117,7 @@ private void processMessageHighlighting() => SchedulerAfterChildren.AddOnce(() =
             if (chatLine == null)
                 return;
 
-            float center = scroll.GetChildPosInContent(chatLine, chatLine.DrawSize / 2) - scroll.DisplayableContent / 2;
+            double center = scroll.GetChildPosInContent(chatLine, chatLine.DrawSize / 2) - scroll.DisplayableContent / 2;
             scroll.ScrollTo(Math.Clamp(center, 0, scroll.ScrollableExtent));
             chatLine.Highlight();
 
diff --git a/osu.Game/Overlays/Mods/ModSelectOverlay.cs b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
@@ -710,13 +710,13 @@ protected override void Update()
 
                 // the bounds below represent the horizontal range of scroll items to be considered fully visible/active, in the scroll's internal coordinate space.
                 // note that clamping is applied to the left scroll bound to ensure scrolling past extents does not change the set of active columns.
-                float leftVisibleBound = Math.Clamp(Current, 0, ScrollableExtent);
-                float rightVisibleBound = leftVisibleBound + DrawWidth;
+                double leftVisibleBound = Math.Clamp(Current, 0, ScrollableExtent);
+                double rightVisibleBound = leftVisibleBound + DrawWidth;
 
                 // if a movement is occurring at this time, the bounds below represent the full range of columns that the scroll movement will encompass.
                 // this will be used to ensure that columns do not change state from active to inactive back and forth until they are fully scrolled past.
-                float leftMovementBound = Math.Min(Current, Target);
-                float rightMovementBound = Math.Max(Current, Target) + DrawWidth;
+                double leftMovementBound = Math.Min(Current, Target);
+                double rightMovementBound = Math.Max(Current, Target) + DrawWidth;
 
                 foreach (var column in Child)
                 {
diff --git a/osu.Game/Overlays/NewsOverlay.cs b/osu.Game/Overlays/NewsOverlay.cs
@@ -136,7 +136,7 @@ protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
             sidebarContainer.Height = DrawHeight;
-            sidebarContainer.Y = Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));
+            sidebarContainer.Y = (float)Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));
         }
 
         private void loadListing(int? year = null)
diff --git a/osu.Game/Overlays/OnlineOverlay.cs b/osu.Game/Overlays/OnlineOverlay.cs
@@ -88,7 +88,7 @@ protected override void UpdateAfterChildren()
             base.UpdateAfterChildren();
 
             // don't block header by applying padding equal to the visible header height
-            loadingContainer.Padding = new MarginPadding { Top = Math.Max(0, Header.Height - ScrollFlow.Current) };
+            loadingContainer.Padding = new MarginPadding { Top = (float)Math.Max(0, Header.Height - ScrollFlow.Current) };
         }
     }
 }
diff --git a/osu.Game/Overlays/OverlayScrollContainer.cs b/osu.Game/Overlays/OverlayScrollContainer.cs
@@ -35,7 +35,7 @@ public partial class OverlayScrollContainer : UserTrackingScrollContainer
 
         public ScrollBackButton Button { get; private set; }
 
-        private readonly Bindable<float?> lastScrollTarget = new Bindable<float?>();
+        private readonly Bindable<double?> lastScrollTarget = new Bindable<double?>();
 
         [BackgroundDependencyLoader]
         private void load()
@@ -63,7 +63,7 @@ protected override void UpdateAfterChildren()
             Button.State = Target > button_scroll_position || lastScrollTarget.Value != null ? Visibility.Visible : Visibility.Hidden;
         }
 
-        protected override void OnUserScroll(float value, bool animated = true, double? distanceDecay = default)
+        protected override void OnUserScroll(double value, bool animated = true, double? distanceDecay = default)
         {
             base.OnUserScroll(value, animated, distanceDecay);
 
@@ -112,7 +112,7 @@ public Visibility State
             private readonly Box background;
             private readonly SpriteIcon spriteIcon;
 
-            public Bindable<float?> LastScrollTarget = new Bindable<float?>();
+            public Bindable<double?> LastScrollTarget = new Bindable<double?>();
 
             protected override HoverSounds CreateHoverSounds(HoverSampleSet sampleSet) => new HoverSounds();
 
diff --git a/osu.Game/Overlays/WikiOverlay.cs b/osu.Game/Overlays/WikiOverlay.cs
@@ -100,7 +100,7 @@ protected override void UpdateAfterChildren()
             if (articlePage != null)
             {
                 articlePage.SidebarContainer.Height = DrawHeight;
-                articlePage.SidebarContainer.Y = Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));
+                articlePage.SidebarContainer.Y = (float)Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));
             }
         }
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
@@ -55,7 +55,7 @@ public bool AlwaysShowControlPoints
         /// <summary>
         /// The timeline's scroll position in the last frame.
         /// </summary>
-        private float lastScrollPosition;
+        private double lastScrollPosition;
 
         /// <summary>
         /// The track time in the last frame.
@@ -322,7 +322,7 @@ private void endUserDrag()
         /// </summary>
         public double VisibleRange => editorClock.TrackLength / Zoom;
 
-        public double TimeAtPosition(float x)
+        public double TimeAtPosition(double x)
         {
             return x / Content.DrawWidth * editorClock.TrackLength;
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs
@@ -182,7 +182,7 @@ private void setZoomTarget(float newZoom, float? focusPoint = null)
         }
 
         private void transformZoomTo(float newZoom, float focusPoint, double duration = 0, Easing easing = Easing.None)
-            => this.TransformTo(this.PopulateTransform(new TransformZoom(focusPoint, zoomedContent.DrawWidth, Current), newZoom, duration, easing));
+            => this.TransformTo(this.PopulateTransform(new TransformZoom(focusPoint, zoomedContent.DrawWidth, (float)Current), newZoom, duration, easing));
 
         /// <summary>
         /// Invoked when <see cref="Zoom"/> has changed.
diff --git a/osu.Game/Screens/Play/HUD/GameplayLeaderboard.cs b/osu.Game/Screens/Play/HUD/GameplayLeaderboard.cs
@@ -114,15 +114,15 @@ protected override void Update()
 
             if (requiresScroll && TrackedScore != null)
             {
-                float scrollTarget = scroll.GetChildPosInContent(TrackedScore) + TrackedScore.DrawHeight / 2 - scroll.DrawHeight / 2;
+                double scrollTarget = scroll.GetChildPosInContent(TrackedScore) + TrackedScore.DrawHeight / 2 - scroll.DrawHeight / 2;
 
                 scroll.ScrollTo(scrollTarget);
             }
 
             const float panel_height = GameplayLeaderboardScore.PANEL_HEIGHT;
 
-            float fadeBottom = scroll.Current + scroll.DrawHeight;
-            float fadeTop = scroll.Current + panel_height;
+            float fadeBottom = (float)(scroll.Current + scroll.DrawHeight);
+            float fadeTop = (float)(scroll.Current + panel_height);
 
             if (scroll.IsScrolledToStart()) fadeTop -= panel_height;
             if (!scroll.IsScrolledToEnd()) fadeBottom -= panel_height;
diff --git a/osu.Game/Screens/Ranking/ScorePanelList.cs b/osu.Game/Screens/Ranking/ScorePanelList.cs
@@ -334,7 +334,7 @@ private IEnumerable<ScorePanelTrackingContainer> applySorting(IEnumerable<Drawab
 
         private partial class Scroll : OsuScrollContainer
         {
-            public new float Target => base.Target;
+            public new double Target => base.Target;
 
             public Scroll()
                 : base(Direction.Horizontal)
@@ -344,7 +344,7 @@ public Scroll()
             /// <summary>
             /// The target that will be scrolled to instantaneously next frame.
             /// </summary>
-            public float? InstantScrollTarget;
+            public double? InstantScrollTarget;
 
             protected override void UpdateAfterChildren()
             {
diff --git a/osu.Game/Screens/Select/BeatmapCarousel.cs b/osu.Game/Screens/Select/BeatmapCarousel.cs
@@ -611,12 +611,12 @@ private void select(CarouselItem? item)
         /// <summary>
         /// The position of the lower visible bound with respect to the current scroll position.
         /// </summary>
-        private float visibleBottomBound => Scroll.Current + DrawHeight + BleedBottom;
+        private float visibleBottomBound => (float)(Scroll.Current + DrawHeight + BleedBottom);
 
         /// <summary>
         /// The position of the upper visible bound with respect to the current scroll position.
         /// </summary>
-        private float visibleUpperBound => Scroll.Current - BleedTop;
+        private float visibleUpperBound => (float)(Scroll.Current - BleedTop);
 
         public void FlushPendingFilterOperations()
         {
@@ -1006,7 +1006,7 @@ private void updateScrollPosition()
                         // we take the difference in scroll height and apply to all visible panels.
                         // this avoids edge cases like when the visible panels is reduced suddenly, causing ScrollContainer
                         // to enter clamp-special-case mode where it animates completely differently to normal.
-                        float scrollChange = scrollTarget.Value - Scroll.Current;
+                        float scrollChange = (float)(scrollTarget.Value - Scroll.Current);
                         Scroll.ScrollTo(scrollTarget.Value, false);
                         foreach (var i in Scroll)
                             i.Y += scrollChange;
@@ -1217,20 +1217,20 @@ public PaddedScrollbar()
             private const float top_padding = 10;
             private const float bottom_padding = 70;
 
-            protected override float ToScrollbarPosition(float scrollPosition)
+            protected override float ToScrollbarPosition(double scrollPosition)
             {
                 if (Precision.AlmostEquals(0, ScrollableExtent))
                     return 0;
 
-                return top_padding + (ScrollbarMovementExtent - (top_padding + bottom_padding)) * (scrollPosition / ScrollableExtent);
+                return (float)(top_padding + (ScrollbarMovementExtent - (top_padding + bottom_padding)) * (scrollPosition / ScrollableExtent));
             }
 
             protected override float FromScrollbarPosition(float scrollbarPosition)
             {
                 if (Precision.AlmostEquals(0, ScrollbarMovementExtent))
                     return 0;
 
-                return ScrollableExtent * ((scrollbarPosition - top_padding) / (ScrollbarMovementExtent - (top_padding + bottom_padding)));
+                return (float)(ScrollableExtent * ((scrollbarPosition - top_padding) / (ScrollbarMovementExtent - (top_padding + bottom_padding))));
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ void step(int scrollIndex)`
`138`	`138`	`AddUntilStep("section top is visible", () =>`
`139`	`139`	`{`
`140`	`140`	`var scrollContainer = container.ChildrenOfType<UserTrackingScrollContainer>().Single();`
`141`		`- float sectionPosition = scrollContainer.GetChildPosInContent(container.Children[scrollIndex]);`
	`141`	`+ double sectionPosition = scrollContainer.GetChildPosInContent(container.Children[scrollIndex]);`
`142`	`142`	`return scrollContainer.Current < sectionPosition;`
`143`	`143`	`});`
`144`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ public void ScrollTo(Drawable target)`
`208`	`208`	`private float getScrollTargetForDrawable(Drawable target)`
`209`	`209`	`{`
`210`	`210`	`// implementation similar to ScrollIntoView but a bit more nuanced.`
`211`		`- return scrollContainer.GetChildPosInContent(target) - scrollContainer.DisplayableContent * scroll_y_centre;`
	`211`	`+ return (float)(scrollContainer.GetChildPosInContent(target) - scrollContainer.DisplayableContent * scroll_y_centre);`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`public void ScrollToTop() => scrollContainer.ScrollTo(0);`
`@@ -259,7 +259,7 @@ protected override void UpdateAfterChildren()`
`259`	`259`	`updateSectionsMargin();`
`260`	`260`	`}`
`261`	`261`
`262`		`- float currentScroll = scrollContainer.Current;`
	`262`	`+ float currentScroll = (float)scrollContainer.Current;`
`263`	`263`
`264`	`264`	`if (currentScroll != lastKnownScroll)`
`265`	`265`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public UserTrackingScrollContainer(Direction direction)`
`35`	`35`	`{`
`36`	`36`	`}`
`37`	`37`
`38`		`- protected override void OnUserScroll(float value, bool animated = true, double? distanceDecay = default)`
	`38`	`+ protected override void OnUserScroll(double value, bool animated = true, double? distanceDecay = default)`
`39`	`39`	`{`
`40`	`40`	`UserScrolling = true;`
`41`	`41`	`base.OnUserScroll(value, animated, distanceDecay);`
`@@ -53,7 +53,7 @@ protected override void ScrollFromMouseEvent(MouseEvent e)`
`53`	`53`	`base.ScrollFromMouseEvent(e);`
`54`	`54`	`}`
`55`	`55`
`56`		`- public new void ScrollTo(float value, bool animated = true, double? distanceDecay = null)`
	`56`	`+ public new void ScrollTo(double value, bool animated = true, double? distanceDecay = null)`
`57`	`57`	`{`
`58`	`58`	`UserScrolling = false;`
`59`	`59`	`base.ScrollTo(value, animated, distanceDecay);`
Original file line number	Diff line number	Diff line change
`@@ -375,8 +375,8 @@ protected override void UpdateAfterChildren()`
`375`	`375`	`{`
`376`	`376`	`base.UpdateAfterChildren();`
`377`	`377`
`378`		`- float fadeBottom = scrollContainer.Current + scrollContainer.DrawHeight;`
`379`		`- float fadeTop = scrollContainer.Current + LeaderboardScore.HEIGHT;`
	`378`	`+ float fadeBottom = (float)(scrollContainer.Current + scrollContainer.DrawHeight);`
	`379`	`+ float fadeTop = (float)(scrollContainer.Current + LeaderboardScore.HEIGHT);`
`380`	`380`
`381`	`381`	`if (!scrollContainer.IsScrolledToEnd())`
`382`	`382`	`fadeBottom -= LeaderboardScore.HEIGHT;`
Original file line number	Diff line number	Diff line change
`@@ -41,13 +41,13 @@ protected override void UpdateAfterChildren()`
`41`	`41`
`42`	`42`	`#region Scroll handling`
`43`	`43`
`44`		`- protected override void OnUserScroll(float value, bool animated = true, double? distanceDecay = null)`
	`44`	`+ protected override void OnUserScroll(double value, bool animated = true, double? distanceDecay = null)`
`45`	`45`	`{`
`46`	`46`	`base.OnUserScroll(value, animated, distanceDecay);`
`47`	`47`	`updateTrackState();`
`48`	`48`	`}`
`49`	`49`
`50`		`- public new void ScrollTo(float value, bool animated = true, double? distanceDecay = null)`
	`50`	`+ public new void ScrollTo(double value, bool animated = true, double? distanceDecay = null)`
`51`	`51`	`{`
`52`	`52`	`base.ScrollTo(value, animated, distanceDecay);`
`53`	`53`	`updateTrackState();`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ protected override void UpdateAfterChildren()`
`136`	`136`	`{`
`137`	`137`	`base.UpdateAfterChildren();`
`138`	`138`	`sidebarContainer.Height = DrawHeight;`
`139`		`- sidebarContainer.Y = Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));`
	`139`	`+ sidebarContainer.Y = (float)Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`private void loadListing(int? year = null)`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ protected override void UpdateAfterChildren()`
`88`	`88`	`base.UpdateAfterChildren();`
`89`	`89`
`90`	`90`	`// don't block header by applying padding equal to the visible header height`
`91`		`- loadingContainer.Padding = new MarginPadding { Top = Math.Max(0, Header.Height - ScrollFlow.Current) };`
	`91`	`+ loadingContainer.Padding = new MarginPadding { Top = (float)Math.Max(0, Header.Height - ScrollFlow.Current) };`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ protected override void UpdateAfterChildren()`
`100`	`100`	`if (articlePage != null)`
`101`	`101`	`{`
`102`	`102`	`articlePage.SidebarContainer.Height = DrawHeight;`
`103`		`- articlePage.SidebarContainer.Y = Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));`
	`103`	`+ articlePage.SidebarContainer.Y = (float)Math.Clamp(ScrollFlow.Current - Header.DrawHeight, 0, Math.Max(ScrollFlow.ScrollContent.DrawHeight - DrawHeight - Header.DrawHeight, 0));`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ private void setZoomTarget(float newZoom, float? focusPoint = null)`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`private void transformZoomTo(float newZoom, float focusPoint, double duration = 0, Easing easing = Easing.None)`
`185`		`- => this.TransformTo(this.PopulateTransform(new TransformZoom(focusPoint, zoomedContent.DrawWidth, Current), newZoom, duration, easing));`
	`185`	`+ => this.TransformTo(this.PopulateTransform(new TransformZoom(focusPoint, zoomedContent.DrawWidth, (float)Current), newZoom, duration, easing));`
`186`	`186`
`187`	`187`	`/// <summary>`
`188`	`188`	`/// Invoked when <see cref="Zoom"/> has changed.`
Original file line number	Diff line number	Diff line change
`@@ -114,15 +114,15 @@ protected override void Update()`
`114`	`114`
`115`	`115`	`if (requiresScroll && TrackedScore != null)`
`116`	`116`	`{`
`117`		`- float scrollTarget = scroll.GetChildPosInContent(TrackedScore) + TrackedScore.DrawHeight / 2 - scroll.DrawHeight / 2;`
	`117`	`+ double scrollTarget = scroll.GetChildPosInContent(TrackedScore) + TrackedScore.DrawHeight / 2 - scroll.DrawHeight / 2;`
`118`	`118`
`119`	`119`	`scroll.ScrollTo(scrollTarget);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`const float panel_height = GameplayLeaderboardScore.PANEL_HEIGHT;`
`123`	`123`
`124`		`- float fadeBottom = scroll.Current + scroll.DrawHeight;`
`125`		`- float fadeTop = scroll.Current + panel_height;`
	`124`	`+ float fadeBottom = (float)(scroll.Current + scroll.DrawHeight);`
	`125`	`+ float fadeTop = (float)(scroll.Current + panel_height);`
`126`	`126`
`127`	`127`	`if (scroll.IsScrolledToStart()) fadeTop -= panel_height;`
`128`	`128`	`if (!scroll.IsScrolledToEnd()) fadeBottom -= panel_height;`