fixed #794

NaBian · NaBian · commit 916d3d12b2f0 · 2021-04-19T21:39:37.000+08:00
diff --git a/src/Shared/HandyControl_Shared/Controls/Panel/RelativePanel.cs b/src/Shared/HandyControl_Shared/Controls/Panel/RelativePanel.cs
@@ -218,7 +218,12 @@ protected override Size MeasureOverride(Size availableSize)
             #region Calc AvailableSize
 
             _childGraph.Reset(false);
-            var boundingSize = _childGraph.GetBoundingSize(Width.IsNaN(), Height.IsNaN(), availableSize);
+
+
+            var calcWidth = Width.IsNaN() && HorizontalAlignment != HorizontalAlignment.Stretch;
+            var calcHeight = Height.IsNaN() && VerticalAlignment != VerticalAlignment.Stretch;
+
+            var boundingSize = _childGraph.GetBoundingSize(calcWidth, calcHeight);
             _childGraph.Reset();
             _childGraph.Measure(boundingSize);
             return boundingSize;
@@ -454,8 +459,6 @@ private void Measure(IEnumerable<GraphNode> nodes, HashSet<DependencyObject> set
 
             private void MeasureChild(GraphNode node)
             {
-                var availableSize = AvailableSize;
-
                 var child = node.Element;
                 child.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
                 node.OriginDesiredSize = child.DesiredSize;
@@ -504,10 +507,10 @@ private void MeasureChild(GraphNode node)
 
                 #region Measure
 
-                var availableHeight = availableSize.Height - node.Top - node.Bottom;
+                var availableHeight = AvailableSize.Height - node.Top - node.Bottom;
                 if (availableHeight.IsNaN())
                 {
-                    availableHeight = availableSize.Height;
+                    availableHeight = AvailableSize.Height;
 
                     if (!node.Top.IsNaN() && node.Bottom.IsNaN())
                     {
@@ -519,10 +522,10 @@ private void MeasureChild(GraphNode node)
                     }
                 }
 
-                var availableWidth = availableSize.Width - node.Left - node.Right;
+                var availableWidth = AvailableSize.Width - node.Left - node.Right;
                 if (availableWidth.IsNaN())
                 {
-                    availableWidth = availableSize.Width;
+                    availableWidth = AvailableSize.Width;
 
                     if (!node.Left.IsNaN() && node.Right.IsNaN())
                     {
@@ -560,7 +563,7 @@ private void MeasureChild(GraphNode node)
 
                     if (node.Left.IsNaN())
                     {
-                        node.Left = availableSize.Width - node.RightOfNode.Right;
+                        node.Left = AvailableSize.Width - node.RightOfNode.Right;
                     }
                 }
 
@@ -573,7 +576,7 @@ private void MeasureChild(GraphNode node)
 
                     if (node.Top.IsNaN())
                     {
-                        node.Top = availableSize.Height - node.BelowNode.Bottom;
+                        node.Top = AvailableSize.Height - node.BelowNode.Bottom;
                     }
                 }
 
@@ -583,8 +586,8 @@ private void MeasureChild(GraphNode node)
 
                 if (node.AlignHorizontalCenterWith != null)
                 {
-                    var halfWidthLeft = (availableSize.Width + node.AlignHorizontalCenterWith.Left - node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;
-                    var halfWidthRight = (availableSize.Width - node.AlignHorizontalCenterWith.Left + node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;
+                    var halfWidthLeft = (AvailableSize.Width + node.AlignHorizontalCenterWith.Left - node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;
+                    var halfWidthRight = (AvailableSize.Width - node.AlignHorizontalCenterWith.Left + node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;
 
                     if (node.Left.IsNaN()) node.Left = halfWidthLeft;
                     else node.Left = (node.Left + halfWidthLeft) * 0.5;
@@ -595,8 +598,8 @@ private void MeasureChild(GraphNode node)
 
                 if (node.AlignVerticalCenterWith != null)
                 {
-                    var halfHeightTop = (availableSize.Height + node.AlignVerticalCenterWith.Top - node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;
-                    var halfHeightBottom = (availableSize.Height - node.AlignVerticalCenterWith.Top + node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;
+                    var halfHeightTop = (AvailableSize.Height + node.AlignVerticalCenterWith.Top - node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;
+                    var halfHeightBottom = (AvailableSize.Height - node.AlignVerticalCenterWith.Top + node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;
 
                     if (node.Top.IsNaN()) node.Top = halfHeightTop;
                     else node.Top = (node.Top + halfHeightTop) * 0.5;
@@ -611,7 +614,7 @@ private void MeasureChild(GraphNode node)
 
                 if (GetAlignHorizontalCenterWithPanel(child))
                 {
-                    var halfSubWidth = (availableSize.Width - childSize.Width) * 0.5;
+                    var halfSubWidth = (AvailableSize.Width - childSize.Width) * 0.5;
 
                     if (node.Left.IsNaN()) node.Left = halfSubWidth;
                     else node.Left = (node.Left + halfSubWidth) * 0.5;
@@ -622,7 +625,7 @@ private void MeasureChild(GraphNode node)
 
                 if (GetAlignVerticalCenterWithPanel(child))
                 {
-                    var halfSubHeight = (availableSize.Height - childSize.Height) * 0.5;
+                    var halfSubHeight = (AvailableSize.Height - childSize.Height) * 0.5;
 
                     if (node.Top.IsNaN()) node.Top = halfSubHeight;
                     else node.Top = (node.Top + halfSubHeight) * 0.5;
@@ -636,37 +639,37 @@ private void MeasureChild(GraphNode node)
                 if (node.Left.IsNaN())
                 {
                     if (!node.Right.IsNaN())
-                        node.Left = availableSize.Width - node.Right - childSize.Width;
+                        node.Left = AvailableSize.Width - node.Right - childSize.Width;
                     else
                     {
                         node.Left = 0;
-                        node.Right = availableSize.Width - childSize.Width;
+                        node.Right = AvailableSize.Width - childSize.Width;
                     }
                 }
                 else if (!node.Left.IsNaN() && node.Right.IsNaN())
                 {
-                    node.Right = availableSize.Width - node.Left - childSize.Width;
+                    node.Right = AvailableSize.Width - node.Left - childSize.Width;
                 }
 
                 if (node.Top.IsNaN())
                 {
                     if (!node.Bottom.IsNaN())
-                        node.Top = availableSize.Height - node.Bottom - childSize.Height;
+                        node.Top = AvailableSize.Height - node.Bottom - childSize.Height;
                     else
                     {
                         node.Top = 0;
-                        node.Bottom = availableSize.Height - childSize.Height;
+                        node.Bottom = AvailableSize.Height - childSize.Height;
                     }
                 }
                 else if (!node.Top.IsNaN() && node.Bottom.IsNaN())
                 {
-                    node.Bottom = availableSize.Height - node.Top - childSize.Height;
+                    node.Bottom = AvailableSize.Height - node.Top - childSize.Height;
                 }
 
                 node.Measured = true;
             }
 
-            public Size GetBoundingSize(bool calcWidth, bool calcHeight, Size availableSize)
+            public Size GetBoundingSize(bool calcWidth, bool calcHeight)
             {
                 var boundingSize = new Size();
 
@@ -677,8 +680,8 @@ public Size GetBoundingSize(bool calcWidth, bool calcHeight, Size availableSize)
                     boundingSize.Height = Math.Max(boundingSize.Height, size.Height);
                 }
 
-                boundingSize.Width = calcWidth ? Math.Max(availableSize.Width, boundingSize.Width) : availableSize.Width;
-                boundingSize.Height = calcHeight ? Math.Max(availableSize.Height, boundingSize.Height) : availableSize.Height;
+                boundingSize.Width = calcWidth ? boundingSize.Width : AvailableSize.Width;
+                boundingSize.Height = calcHeight ? boundingSize.Height : AvailableSize.Height;
                 return boundingSize;
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -218,7 +218,12 @@ protected override Size MeasureOverride(Size availableSize)`
`218`	`218`	`#region Calc AvailableSize`
`219`	`219`
`220`	`220`	`_childGraph.Reset(false);`
`221`		`- var boundingSize = _childGraph.GetBoundingSize(Width.IsNaN(), Height.IsNaN(), availableSize);`
	`221`	`+`
	`222`	`+`
	`223`	`+ var calcWidth = Width.IsNaN() && HorizontalAlignment != HorizontalAlignment.Stretch;`
	`224`	`+ var calcHeight = Height.IsNaN() && VerticalAlignment != VerticalAlignment.Stretch;`
	`225`	`+`
	`226`	`+ var boundingSize = _childGraph.GetBoundingSize(calcWidth, calcHeight);`
`222`	`227`	`_childGraph.Reset();`
`223`	`228`	`_childGraph.Measure(boundingSize);`
`224`	`229`	`return boundingSize;`
`@@ -454,8 +459,6 @@ private void Measure(IEnumerable<GraphNode> nodes, HashSet<DependencyObject> set`
`454`	`459`
`455`	`460`	`private void MeasureChild(GraphNode node)`
`456`	`461`	`{`
`457`		`- var availableSize = AvailableSize;`
`458`		`-`
`459`	`462`	`var child = node.Element;`
`460`	`463`	`child.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));`
`461`	`464`	`node.OriginDesiredSize = child.DesiredSize;`
`@@ -504,10 +507,10 @@ private void MeasureChild(GraphNode node)`
`504`	`507`
`505`	`508`	`#region Measure`
`506`	`509`
`507`		`- var availableHeight = availableSize.Height - node.Top - node.Bottom;`
	`510`	`+ var availableHeight = AvailableSize.Height - node.Top - node.Bottom;`
`508`	`511`	`if (availableHeight.IsNaN())`
`509`	`512`	`{`
`510`		`- availableHeight = availableSize.Height;`
	`513`	`+ availableHeight = AvailableSize.Height;`
`511`	`514`
`512`	`515`	`if (!node.Top.IsNaN() && node.Bottom.IsNaN())`
`513`	`516`	`{`
`@@ -519,10 +522,10 @@ private void MeasureChild(GraphNode node)`
`519`	`522`	`}`
`520`	`523`	`}`
`521`	`524`
`522`		`- var availableWidth = availableSize.Width - node.Left - node.Right;`
	`525`	`+ var availableWidth = AvailableSize.Width - node.Left - node.Right;`
`523`	`526`	`if (availableWidth.IsNaN())`
`524`	`527`	`{`
`525`		`- availableWidth = availableSize.Width;`
	`528`	`+ availableWidth = AvailableSize.Width;`
`526`	`529`
`527`	`530`	`if (!node.Left.IsNaN() && node.Right.IsNaN())`
`528`	`531`	`{`
`@@ -560,7 +563,7 @@ private void MeasureChild(GraphNode node)`
`560`	`563`
`561`	`564`	`if (node.Left.IsNaN())`
`562`	`565`	`{`
`563`		`- node.Left = availableSize.Width - node.RightOfNode.Right;`
	`566`	`+ node.Left = AvailableSize.Width - node.RightOfNode.Right;`
`564`	`567`	`}`
`565`	`568`	`}`
`566`	`569`
`@@ -573,7 +576,7 @@ private void MeasureChild(GraphNode node)`
`573`	`576`
`574`	`577`	`if (node.Top.IsNaN())`
`575`	`578`	`{`
`576`		`- node.Top = availableSize.Height - node.BelowNode.Bottom;`
	`579`	`+ node.Top = AvailableSize.Height - node.BelowNode.Bottom;`
`577`	`580`	`}`
`578`	`581`	`}`
`579`	`582`
`@@ -583,8 +586,8 @@ private void MeasureChild(GraphNode node)`
`583`	`586`
`584`	`587`	`if (node.AlignHorizontalCenterWith != null)`
`585`	`588`	`{`
`586`		`- var halfWidthLeft = (availableSize.Width + node.AlignHorizontalCenterWith.Left - node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;`
`587`		`- var halfWidthRight = (availableSize.Width - node.AlignHorizontalCenterWith.Left + node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;`
	`589`	`+ var halfWidthLeft = (AvailableSize.Width + node.AlignHorizontalCenterWith.Left - node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;`
	`590`	`+ var halfWidthRight = (AvailableSize.Width - node.AlignHorizontalCenterWith.Left + node.AlignHorizontalCenterWith.Right - childSize.Width) * 0.5;`
`588`	`591`
`589`	`592`	`if (node.Left.IsNaN()) node.Left = halfWidthLeft;`
`590`	`593`	`else node.Left = (node.Left + halfWidthLeft) * 0.5;`
`@@ -595,8 +598,8 @@ private void MeasureChild(GraphNode node)`
`595`	`598`
`596`	`599`	`if (node.AlignVerticalCenterWith != null)`
`597`	`600`	`{`
`598`		`- var halfHeightTop = (availableSize.Height + node.AlignVerticalCenterWith.Top - node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;`
`599`		`- var halfHeightBottom = (availableSize.Height - node.AlignVerticalCenterWith.Top + node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;`
	`601`	`+ var halfHeightTop = (AvailableSize.Height + node.AlignVerticalCenterWith.Top - node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;`
	`602`	`+ var halfHeightBottom = (AvailableSize.Height - node.AlignVerticalCenterWith.Top + node.AlignVerticalCenterWith.Bottom - childSize.Height) * 0.5;`
`600`	`603`
`601`	`604`	`if (node.Top.IsNaN()) node.Top = halfHeightTop;`
`602`	`605`	`else node.Top = (node.Top + halfHeightTop) * 0.5;`
`@@ -611,7 +614,7 @@ private void MeasureChild(GraphNode node)`
`611`	`614`
`612`	`615`	`if (GetAlignHorizontalCenterWithPanel(child))`
`613`	`616`	`{`
`614`		`- var halfSubWidth = (availableSize.Width - childSize.Width) * 0.5;`
	`617`	`+ var halfSubWidth = (AvailableSize.Width - childSize.Width) * 0.5;`
`615`	`618`
`616`	`619`	`if (node.Left.IsNaN()) node.Left = halfSubWidth;`
`617`	`620`	`else node.Left = (node.Left + halfSubWidth) * 0.5;`
`@@ -622,7 +625,7 @@ private void MeasureChild(GraphNode node)`
`622`	`625`
`623`	`626`	`if (GetAlignVerticalCenterWithPanel(child))`
`624`	`627`	`{`
`625`		`- var halfSubHeight = (availableSize.Height - childSize.Height) * 0.5;`
	`628`	`+ var halfSubHeight = (AvailableSize.Height - childSize.Height) * 0.5;`
`626`	`629`
`627`	`630`	`if (node.Top.IsNaN()) node.Top = halfSubHeight;`
`628`	`631`	`else node.Top = (node.Top + halfSubHeight) * 0.5;`
`@@ -636,37 +639,37 @@ private void MeasureChild(GraphNode node)`
`636`	`639`	`if (node.Left.IsNaN())`
`637`	`640`	`{`
`638`	`641`	`if (!node.Right.IsNaN())`
`639`		`- node.Left = availableSize.Width - node.Right - childSize.Width;`
	`642`	`+ node.Left = AvailableSize.Width - node.Right - childSize.Width;`
`640`	`643`	`else`
`641`	`644`	`{`
`642`	`645`	`node.Left = 0;`
`643`		`- node.Right = availableSize.Width - childSize.Width;`
	`646`	`+ node.Right = AvailableSize.Width - childSize.Width;`
`644`	`647`	`}`
`645`	`648`	`}`
`646`	`649`	`else if (!node.Left.IsNaN() && node.Right.IsNaN())`
`647`	`650`	`{`
`648`		`- node.Right = availableSize.Width - node.Left - childSize.Width;`
	`651`	`+ node.Right = AvailableSize.Width - node.Left - childSize.Width;`
`649`	`652`	`}`
`650`	`653`
`651`	`654`	`if (node.Top.IsNaN())`
`652`	`655`	`{`
`653`	`656`	`if (!node.Bottom.IsNaN())`
`654`		`- node.Top = availableSize.Height - node.Bottom - childSize.Height;`
	`657`	`+ node.Top = AvailableSize.Height - node.Bottom - childSize.Height;`
`655`	`658`	`else`
`656`	`659`	`{`
`657`	`660`	`node.Top = 0;`
`658`		`- node.Bottom = availableSize.Height - childSize.Height;`
	`661`	`+ node.Bottom = AvailableSize.Height - childSize.Height;`
`659`	`662`	`}`
`660`	`663`	`}`
`661`	`664`	`else if (!node.Top.IsNaN() && node.Bottom.IsNaN())`
`662`	`665`	`{`
`663`		`- node.Bottom = availableSize.Height - node.Top - childSize.Height;`
	`666`	`+ node.Bottom = AvailableSize.Height - node.Top - childSize.Height;`
`664`	`667`	`}`
`665`	`668`
`666`	`669`	`node.Measured = true;`
`667`	`670`	`}`
`668`	`671`
`669`		`- public Size GetBoundingSize(bool calcWidth, bool calcHeight, Size availableSize)`
	`672`	`+ public Size GetBoundingSize(bool calcWidth, bool calcHeight)`
`670`	`673`	`{`
`671`	`674`	`var boundingSize = new Size();`
`672`	`675`
`@@ -677,8 +680,8 @@ public Size GetBoundingSize(bool calcWidth, bool calcHeight, Size availableSize)`
`677`	`680`	`boundingSize.Height = Math.Max(boundingSize.Height, size.Height);`
`678`	`681`	`}`
`679`	`682`
`680`		`- boundingSize.Width = calcWidth ? Math.Max(availableSize.Width, boundingSize.Width) : availableSize.Width;`
`681`		`- boundingSize.Height = calcHeight ? Math.Max(availableSize.Height, boundingSize.Height) : availableSize.Height;`
	`683`	`+ boundingSize.Width = calcWidth ? boundingSize.Width : AvailableSize.Width;`
	`684`	`+ boundingSize.Height = calcHeight ? boundingSize.Height : AvailableSize.Height;`
`682`	`685`	`return boundingSize;`
`683`	`686`	`}`
`684`	`687`	`}`