Cleanup layout code and rename nodes

GridLikeNode is a base class for containers like SplitPanelNode.
LayoutFunctionNode uses a function to compute base layout.

Author: veselink1

FancyWM.Layouts/GridLayout.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-
 using WinMan;
 
 namespace FancyWM.Layouts
@@ -12,29 +11,67 @@ public class GridLayout(int spacing) : ILayoutFunction
 
         public IReadOnlyList<Rectangle> Execute(Rectangle availableArea, IEnumerable<Constraints> constraints)
         {
-            bool isHorizontal = availableArea.Width >= availableArea.Height;
+            var (rows, columns) = CalculateGridDimensions(constraints.Count(), availableArea.Width, availableArea.Height);
+
+            var constraintList = constraints.ToList();
+            var result = new List<Rectangle>();
 
-            var count = constraints.Count();
-            var root = (int)Math.Round(Math.Sqrt(count));
+            if (constraintList.Count == 0)
+            {
+                return result;
+            }
 
-            var w = (availableArea.Width - Spacing * (root + 1)) / root;
-            var h = (availableArea.Height - Spacing * (root + 1)) / root;
+            double cellWidth = (double)availableArea.Width / columns;
+            double cellHeight = (double)availableArea.Height / rows;
 
-            List<Rectangle> rects = [];
-            for (int i = 0; i < w; i++)
+            for (int i = 0; i < constraintList.Count; i++)
             {
-                for (int j = 0; j < h; j++)
+                if (i >= rows * columns)
                 {
-
+                    break;
                 }
+
+                int row = i / columns;
+                int col = i % columns;
+
+                int slotLeft = availableArea.Left + (int)(col * cellWidth);
+                int slotRight = (col == columns - 1) 
+                    ? availableArea.Right 
+                    : availableArea.Left + (int)((col + 1) * cellWidth);
+                
+                int slotTop = availableArea.Top + (int)(row * cellHeight);
+                int slotBottom = (row == rows - 1) 
+                    ? availableArea.Bottom 
+                    : availableArea.Top + (int)((row + 1) * cellHeight);
+
+                int left = slotLeft + (col == 0 ? Spacing : Spacing / 2);
+                int right = slotRight - (col == columns - 1 ? Spacing : Spacing / 2);
+                int top = slotTop + (row == 0 ? Spacing : Spacing / 2);
+                int bottom = slotBottom - (row == rows - 1 ? Spacing : Spacing / 2);
+
+                result.Add(new Rectangle(
+                    left: Math.Min(left, right),
+                    top: Math.Min(top, bottom),
+                    bottom: Math.Max(top, bottom),
+                    right: Math.Max(left, right)
+                ));
+            }
+
+            return result;
+        }
+
+        private (int rows, int columns) CalculateGridDimensions(int count, int width, int height)
+        {
+            int a = 1;
+            while (a * a < count) a++;
+            int b = (count + a - 1) / a;
+
+            if (width > height && a >= b)
+            {
+                (b, a) = (a, b);
             }
 
-            return constraints.Select((rect, index) => Rectangle.OffsetAndSize(
-                left: availableArea.Left + (w * index) + Spacing * (index + 1),
-                top: availableArea.Top + Spacing,
-                width: w,
-                height: h - 2 * Spacing
-            )).ToArray();
+            return (a, b);
         }
     }
 }

FancyWM.Layouts/Tiling/GridLikeNode.cs

@@ -0,0 +1,11 @@
+namespace FancyWM.Layouts.Tiling
+{
+    public abstract class GridLikeNode : PanelNode
+    {
+        public abstract bool CanResizeInOrientation(PanelOrientation orientation);
+
+        public abstract bool ResizeTo(TilingNode node, double newLength, GrowDirection direction);
+
+        public abstract bool ResizeBy(TilingNode node, double delta, GrowDirection direction);
+    }
+}

FancyWM.Layouts/Tiling/StaticPanelNode.cs …yWM.Layouts/Tiling/LayoutFunctionNode.csFancyWM.Layouts/Tiling/StaticPanelNode.cs renamed to FancyWM.Layouts/Tiling/LayoutFunctionNode.cs FancyWM.Layouts/Tiling/StaticPanelNode.cs renamed to FancyWM.Layouts/Tiling/LayoutFunctionNode.cs

@@ -6,7 +6,7 @@
 
 namespace FancyWM.Layouts.Tiling
 {
-    public class StaticPanelNode(ILayoutFunction layoutFunction) : PanelNode
+    public class LayoutFunctionNode(ILayoutFunction layoutFunction) : GridLikeNode
     {
         public override TilingNodeType Type => TilingNodeType.Static;
 
@@ -47,7 +47,7 @@ internal override void ArrangeCore(RectangleF rectangle)
 
         public override object Clone()
         {
-            var copy = (StaticPanelNode)base.Clone();
+            var copy = (LayoutFunctionNode)base.Clone();
             copy.m_children = m_children.Select(x => (TilingNode)x.Clone()).ToList();
             foreach (var child in copy.m_children)
             {
@@ -58,22 +58,42 @@ public override object Clone()
 
         internal override void MeasureCore()
         {
-            throw new NotImplementedException();
+            foreach (var node in m_children)
+            {
+                node.Measure();
+            }
         }
 
         public override void Move(int fromIndex, int toIndex)
         {
-            throw new NotImplementedException();
+            var n = m_children[fromIndex];
+            m_children.RemoveAt(fromIndex);
+            m_children.Insert(toIndex, n);
         }
 
         public override Point GetMaxChildSize(TilingNode node)
         {
-            throw new NotImplementedException();
+            return ComputedContentRectangle.Size;
         }
 
         public override Point GetMaxSizeForInsert(TilingNode node)
         {
-            throw new NotImplementedException();
+            return ComputedContentRectangle.Size;
+        }
+
+        public override bool CanResizeInOrientation(PanelOrientation orientation)
+        {
+            return false;
+        }
+
+        public override bool ResizeTo(TilingNode node, double newLength, GrowDirection direction)
+        {
+            return false;
+        }
+
+        public override bool ResizeBy(TilingNode node, double delta, GrowDirection direction)
+        {
+            return false;
         }
     }
 }

FancyWM.Layouts/Tiling/PanelNode.cs

@@ -151,9 +151,4 @@ public void RemovePlaceholders()
             }
         }
     }
-
-    //class StackPanel : Panel
-    //{
-    //    public override NodeType Type => NodeType.Stack;
-    //}
 }

FancyWM.Layouts/Tiling/SplitPanelNode.cs

@@ -9,7 +9,7 @@
 
 namespace FancyWM.Layouts.Tiling
 {
-    public class SplitPanelNode : PanelNode
+    public class SplitPanelNode : GridLikeNode
     {
         public override TilingNodeType Type => TilingNodeType.Split;
 
@@ -152,7 +152,12 @@ internal override void ArrangeCore(RectangleF rect)
             }
         }
 
-        public bool ResizeTo(TilingNode node, double newLength, GrowDirection direction)
+        public override bool CanResizeInOrientation(PanelOrientation orientation)
+        {
+            return Orientation == orientation;
+        }
+
+        public override bool ResizeTo(TilingNode node, double newLength, GrowDirection direction)
         {
             if (Children.Count == 1)
             {
@@ -163,7 +168,7 @@ public bool ResizeTo(TilingNode node, double newLength, GrowDirection direction)
             return ResizeBy(node, newLength - m_constraints[index].Width, direction);
         }
 
-        public bool ResizeBy(TilingNode node, double delta, GrowDirection direction)
+        public override bool ResizeBy(TilingNode node, double delta, GrowDirection direction)
         {
             if (Children.Count == 1)
             {

FancyWM.Layouts/Tiling/WindowNode.cs

@@ -41,9 +41,4 @@ internal override void MeasureCore()
         }
 
     }
-
-    //class StackPanel : Panel
-    //{
-    //    public override NodeType Type => NodeType.Stack;
-    //}
 }

FancyWM/TilingService.Private.cs

@@ -1329,7 +1329,7 @@ void RegisterInSavedPanel()
                     savedLocation.Parent.Attach(index, window);
 
                     // Restore size
-                    if (window.Parent is SplitPanelNode splitPanel)
+                    if (window.Parent is GridLikeNode gridNode)
                     {
                         if (m_backend.GetTree(m_workspace.VirtualDesktopManager.CurrentDesktop) is DesktopTree tree)
                         {
@@ -1342,13 +1342,13 @@ void RegisterInSavedPanel()
                             catch (UnsatisfiableFlexConstraintsException)
                             {
                             }
-                            if (splitPanel.Orientation == PanelOrientation.Horizontal)
+                            if (gridNode.CanResizeInOrientation(PanelOrientation.Horizontal))
                             {
-                                splitPanel.ResizeTo(window, savedLocation.ComputedRectangle.Width, GrowDirection.Both);
+                                gridNode.ResizeTo(window, savedLocation.ComputedRectangle.Width, GrowDirection.Both);
                             }
                             else
                             {
-                                splitPanel.ResizeTo(window, savedLocation.ComputedRectangle.Height, GrowDirection.Both);
+                                gridNode.ResizeTo(window, savedLocation.ComputedRectangle.Height, GrowDirection.Both);
                             }
                         }
                     }

FancyWM/TilingService.cs

@@ -596,10 +596,10 @@ public bool CanResize(PanelOrientation orientation, double displayPercentage)
                 var horizontalDelta = (int)(display.WorkArea.Width * displayPercentage);
 
                 var grandparent = focusedNode.Ancestors
-                        .Select(x => x as SplitPanelNode)
+                        .Select(x => x as GridLikeNode)
                         .Where(x => x != null)
-                        .FirstOrDefault(x => x!.Orientation == orientation);
-                if (grandparent is SplitPanelNode s && s.Orientation == orientation)
+                        .FirstOrDefault(x => x!.CanResizeInOrientation(orientation));
+                if (grandparent != null)
                 {
                     double newSize;
                     switch (orientation)

FancyWM/TilingWorkspace.cs

@@ -120,11 +120,18 @@ public TilingWorkspace()
         {
         }
 
+        public PanelNode CreateRoot(PanelOrientation orientation)
+        {
+            // return new LayoutFunctionNode(new GridLayout(8));
+            // return new LayoutFunctionNode(new RatioLayout(0.5, 8));
+            return new SplitPanelNode { Orientation = orientation };
+        }
+
         public void RegisterDesktop(IVirtualDesktop virtualDesktop, PanelOrientation orientation)
         {
             var tree = new DesktopTree
             {
-                Root = new SplitPanelNode { Orientation = orientation }
+                Root = CreateRoot(orientation)
             };
             m_states.AddState(virtualDesktop, new DesktopState
             {
@@ -378,9 +385,9 @@ private static int FindInsertionIndex(TilingNode nodeAtPoint, Point pt)
         {
             Debug.Assert(nodeAtPoint.Parent != null);
             var insertionIndex = nodeAtPoint.Parent!.IndexOf(nodeAtPoint);
-            if (nodeAtPoint.Parent is SplitPanelNode split)
+            if (nodeAtPoint.Parent is GridLikeNode grid)
             {
-                if (split.Orientation == PanelOrientation.Horizontal)
+                if (grid.CanResizeInOrientation(PanelOrientation.Horizontal))
                 {
                     if (nodeAtPoint.ComputedRectangle.Left + nodeAtPoint.ComputedRectangle.Width / 2 < pt.X)
                     {
@@ -612,10 +619,10 @@ public void ResizeNode(TilingNode node, Rectangle newPosition, Rectangle oldPosi
         {
             if (newPosition.Width != oldPosition.Width)
             {
-                SplitPanelNode? p = node.Ancestors
-                    .Select(x => x as SplitPanelNode)
+                GridLikeNode? p = node.Ancestors
+                    .Select(x => x as GridLikeNode)
                     .Where(x => x != null)
-                    .FirstOrDefault(x => x!.Orientation == PanelOrientation.Horizontal);
+                    .FirstOrDefault(x => x!.CanResizeInOrientation(PanelOrientation.Horizontal));
 
                 if (p != null)
                 {
@@ -647,10 +654,10 @@ public void ResizeNode(TilingNode node, Rectangle newPosition, Rectangle oldPosi
 
             if (newPosition.Height != oldPosition.Height)
             {
-                SplitPanelNode? p = node.Ancestors
-                    .Select(x => x as SplitPanelNode)
+                GridLikeNode? p = node.Ancestors
+                    .Select(x => x as GridLikeNode)
                     .Where(x => x != null)
-                    .FirstOrDefault(x => x!.Orientation == PanelOrientation.Vertical);
+                    .FirstOrDefault(x => x!.CanResizeInOrientation(PanelOrientation.Vertical));
 
                 if (p != null)
                 {