Merge remote-tracking branch 'origin/main'

Author: Ellpeck

CHANGELOG.md

@@ -7,6 +7,7 @@ MLEM uses [semantic versioning](https://semver.org/). Potentially breaking chang
 Additions
 - Added UiSystem.OnElementAreaDirty and Element.OnAreaDirty events
 - Added Element.DebugName to allow describing ui elements in ToString
+- Added ILayoutItem.OnLayoutRecursionSettled which is called when recursive ui layouting has finished
 
 Improvements
 - Made the exception thrown after the element recursion limit is reached more helpful

MLEM.Ui/Elements/Element.cs

@@ -1104,6 +1104,32 @@ public Vector2 TransformInverseAll(Vector2 position) {
             return this.TransformInverse(position);
         }
 
+        /// <summary>
+        /// A method called by <see cref="UiLayouter.Layout{T}"/> when a layout item's size is being recalculated based on its children.
+        /// </summary>
+        /// <param name="recursion">The current recursion depth.</param>
+        /// <param name="relevantChild">The child that triggered the layout recursion. May be <see langword="null"/> in case the source of the layout recursion is unknown.</param>
+        protected virtual void OnLayoutRecursion(int recursion, ILayoutItem relevantChild) {
+            this.System.Metrics.SummedRecursionDepth++;
+            if (recursion > this.System.Metrics.MaxRecursionDepth)
+                this.System.Metrics.MaxRecursionDepth = recursion;
+
+            if (recursion >= Element.RecursionLimit) {
+                var exceptionText = $"The area of {this} has recursively updated more often than the configured Element.RecursionLimit. This issue may occur due to this element or one of its children containing conflicting auto-sizing settings, a custom element setting its area dirty too frequently, or this element being part of a complex layout tree that should be split up into multiple groups.";
+                if (relevantChild != null)
+                    exceptionText += $" Does its child {relevantChild} contain any conflicting auto-sizing settings?";
+                throw new ArithmeticException(exceptionText);
+            }
+        }
+
+        /// <summary>
+        /// A method called by <see cref="UiLayouter.Layout{T}"/> when a layout item's size is being calculated, but recursive calculations have settled.
+        /// Also see <see cref="OnLayoutRecursion"/>, which is called for every recursive operation during element layouting.
+        /// </summary>
+        /// <param name="totalRecursion">The total reached recursion depth.</param>
+        /// <param name="elementInternal"><see langword="true"/> if the settled recursive operation was element-internal (ie related to properties like <see cref="SetWidthBasedOnChildren"/> and <see cref="SetHeightBasedOnChildren"/>); <see langword="false"/> if the settled recursive operation was related to recursively updated children or parents of this element.</param>
+        protected virtual void OnLayoutRecursionSettled(int totalRecursion, bool elementInternal) {}
+
         /// <summary>
         /// Called when this element is added to a <see cref="UiSystem"/> and, optionally, a given <see cref="RootElement"/>.
         /// This method is called in <see cref="AddChild{T}"/> for a parent whose <see cref="System"/> is set, as well as <see cref="UiSystem.Add"/>.
@@ -1131,16 +1157,11 @@ protected internal virtual void RemovedFromUi() {
         }
 
         void ILayoutItem.OnLayoutRecursion(int recursion, ILayoutItem relevantChild) {
-            this.System.Metrics.SummedRecursionDepth++;
-            if (recursion > this.System.Metrics.MaxRecursionDepth)
-                this.System.Metrics.MaxRecursionDepth = recursion;
+            this.OnLayoutRecursion(recursion, relevantChild);
+        }
 
-            if (recursion >= Element.RecursionLimit) {
-                var exceptionText = $"The area of {this} has recursively updated more often than the configured Element.RecursionLimit. This issue may occur due to this element or one of its children containing conflicting auto-sizing settings, a custom element setting its area dirty too frequently, or this element being part of a complex layout tree that should be split up into multiple groups.";
-                if (relevantChild != null)
-                    exceptionText += $" Does its child {relevantChild} contain any conflicting auto-sizing settings?";
-                throw new ArithmeticException(exceptionText);
-            }
+        void ILayoutItem.OnLayoutRecursionSettled(int totalRecursion, bool elementInternal) {
+            this.OnLayoutRecursionSettled(totalRecursion, elementInternal);
         }
 
         Vector2 ILayoutItem.CalcActualSize(RectangleF parentArea) {

MLEM.Ui/Elements/Panel.cs

@@ -57,7 +57,6 @@ public StyleProp<float> ScrollBarOffset {
 
         private readonly List<Element> relevantChildren = new List<Element>();
         private readonly HashSet<Element> scrolledChildren = new HashSet<Element>();
-        private readonly float[] scrollBarMaxHistory;
         private readonly bool scrollOverflow;
 
         private RenderTarget2D renderTarget;
@@ -67,6 +66,7 @@ public StyleProp<float> ScrollBarOffset {
         private float lastScrollOffset;
         private bool childrenDirtyForScroll;
         private bool scrollBarMaxHistoryDirty;
+        private float[] scrollBarMaxHistory;
 
         /// <summary>
         /// Creates a new panel with the given settings.
@@ -85,10 +85,6 @@ public Panel(Anchor anchor, Vector2 size, Vector2 positionOffset, bool setHeight
             base.CanBeSelected = false;
 
             if (scrollOverflow) {
-                this.scrollBarMaxHistory = new float[3];
-                this.scrollBarMaxHistoryDirty = true;
-                this.ResetScrollBarMaxHistory();
-
                 this.ScrollBar = new ScrollBar(Anchor.TopRight, Vector2.Zero, 0, 0) {
                     OnValueChanged = (element, value) => this.ScrollChildren(),
                     CanAutoAnchorsAttach = false,
@@ -337,17 +333,29 @@ protected virtual void ScrollSetup() {
                 childrenHeight = 0;
             }
 
+            // height doesn't change when modifying ChildPadding below, so avoid a needless update later
+            var areaHeight = this.ChildPaddedArea.Height;
             // the max value of the scroll bar is the amount of non-scaled pixels taken up by overflowing components
-            var scrollBarMax = Math.Max(0, (childrenHeight - this.ChildPaddedArea.Height) / this.Scale);
+            var scrollBarMax = Math.Max(0, (childrenHeight - areaHeight) / this.Scale);
+
             // avoid an infinite show/hide oscillation that occurs while updating our area by simply using the maximum recent height in that case
-            if (this.scrollBarMaxHistory[0].Equals(this.scrollBarMaxHistory[2], Element.Epsilon) && this.scrollBarMaxHistory[1].Equals(scrollBarMax, Element.Epsilon))
-                scrollBarMax = Math.Max(scrollBarMax, this.scrollBarMaxHistory.Max());
-            if (!this.ScrollBar.MaxValue.Equals(scrollBarMax, Element.Epsilon)) {
-                this.scrollBarMaxHistory[0] = this.scrollBarMaxHistory[1];
-                this.scrollBarMaxHistory[1] = this.scrollBarMaxHistory[2];
-                this.scrollBarMaxHistory[2] = scrollBarMax;
-                this.scrollBarMaxHistoryDirty = true;
+            if (this.ScrollBar.AutoHideWhenEmpty && this.ScrollBar.MaxValue > Element.Epsilon != scrollBarMax > Element.Epsilon) {
+                if (this.scrollBarMaxHistory == null) {
+                    this.scrollBarMaxHistory = new float[3];
+                    this.scrollBarMaxHistoryDirty = true;
+                    this.ResetScrollBarMaxHistory();
+                }
+                if (this.scrollBarMaxHistory[0].Equals(this.scrollBarMaxHistory[2], Element.Epsilon) && this.scrollBarMaxHistory[1].Equals(scrollBarMax, Element.Epsilon))
+                    scrollBarMax = Math.Max(scrollBarMax, this.scrollBarMaxHistory.Max());
+                if (!scrollBarMax.Equals(this.scrollBarMaxHistory[2], Element.Epsilon)) {
+                    this.scrollBarMaxHistory[0] = this.scrollBarMaxHistory[1];
+                    this.scrollBarMaxHistory[1] = this.scrollBarMaxHistory[2];
+                    this.scrollBarMaxHistory[2] = scrollBarMax;
+                    this.scrollBarMaxHistoryDirty = true;
+                }
+            }
 
+            if (!this.ScrollBar.MaxValue.Equals(scrollBarMax, Element.Epsilon)) {
                 this.ScrollBar.MaxValue = scrollBarMax;
                 this.relevantChildrenDirty = true;
             }
@@ -361,7 +369,7 @@ protected virtual void ScrollSetup() {
             }
 
             // the scroller height has the same relation to the scroll bar height as the visible area has to the total height of the panel's content
-            var scrollerHeight = Math.Min(this.ChildPaddedArea.Height / childrenHeight / this.Scale, 1) * this.ScrollBar.Area.Height;
+            var scrollerHeight = Math.Min(areaHeight / childrenHeight / this.Scale, 1) * this.ScrollBar.Area.Height;
             this.ScrollBar.ScrollerSize = new Vector2(this.ScrollerSize.Value.X, Math.Max(this.ScrollerSize.Value.Y, scrollerHeight));
 
             // update the render target

MLEM.Ui/UiLayouter.cs

@@ -26,9 +26,12 @@ public static void Layout<T>(T item, ref int layoutRecursionTracker, float epsil
 
             var internalRecursion = 0;
             UpdateDisplayArea();
+            item.OnLayoutRecursionSettled(internalRecursion, true);
 
-            if (initiatedLayouting)
+            if (initiatedLayouting) {
+                item.OnLayoutRecursionSettled(layoutRecursionTracker, false);
                 layoutRecursionTracker = 0;
+            }
 
             void UpdateDisplayArea(Vector2? overrideSize = null) {
                 var parentArea = item.ParentArea;
@@ -376,11 +379,10 @@ public interface ILayoutItem {
         bool CanAutoAnchorsAttach { get; }
 
         /// <summary>
-        /// Calculates the actual size that this layout item should take up, based on the area that its parent encompasses.
-        /// By default, this is based on the information specified in <see cref="System.Drawing.Size"/>'s documentation.
+        /// Calculates the actual total size that this element should take up.
         /// </summary>
-        /// <param name="parentArea">This parent's area, or the ui system's viewport if it has no parent</param>
-        /// <returns>The actual size of this layout item, any scaling into account</returns>
+        /// <param name="parentArea">This parent's area, or the ui system's viewport if it has no parent.</param>
+        /// <returns>The actual size of this element.</returns>
         Vector2 CalcActualSize(RectangleF parentArea);
 
         /// <summary>
@@ -401,10 +403,19 @@ public interface ILayoutItem {
 
         /// <summary>
         /// A method called by <see cref="UiLayouter.Layout{T}"/> when a layout item's size is being recalculated based on its children.
+        /// Also see <see cref="OnLayoutRecursionSettled"/>, which is called after recursive operations during element layouting have completed.
         /// </summary>
         /// <param name="recursion">The current recursion depth.</param>
         /// <param name="relevantChild">The child that triggered the layout recursion. May be <see langword="null"/> in case the source of the layout recursion is unknown.</param>
         void OnLayoutRecursion(int recursion, ILayoutItem relevantChild);
 
+        /// <summary>
+        /// A method called by <see cref="UiLayouter.Layout{T}"/> when a layout item's size is being calculated, but recursive calculations have settled.
+        /// Also see <see cref="OnLayoutRecursion"/>, which is called for every recursive operation during element layouting.
+        /// </summary>
+        /// <param name="totalRecursion">The total reached recursion depth.</param>
+        /// <param name="elementInternal"><see langword="true"/> if the settled recursive operation was element-internal (ie related to properties like <see cref="SetWidthBasedOnChildren"/> and <see cref="SetHeightBasedOnChildren"/>); <see langword="false"/> if the settled recursive operation was related to recursively updated children or parents of this element.</param>
+        void OnLayoutRecursionSettled(int totalRecursion, bool elementInternal);
+
     }
 }