The automatic layout algorithm can now be configured on individual views.

Author: simonbrowndotje

Structurizr.Core.Tests/View/AutomaticLayoutTests.cs

@@ -0,0 +1,66 @@
+using System;
+using Xunit;
+
+namespace Structurizr.Core.Tests.View
+{
+    public class AutomaticLayoutTests
+    {
+        [Fact]
+        public void Test_AutomaticLayout()
+        {
+            AutomaticLayout automaticLayout = new AutomaticLayout(RankDirection.LeftRight, 100, 200, 300, true);
+
+            Assert.Equal(RankDirection.LeftRight, automaticLayout.RankDirection);
+            Assert.Equal(100, automaticLayout.RankSeparation);
+            Assert.Equal(200, automaticLayout.NodeSeparation);
+            Assert.Equal(300, automaticLayout.EdgeSeparation);
+            Assert.True(automaticLayout.Vertices);
+        }
+
+        [Fact]
+        public void Test_RankSeparation_ThrowsAnException_WhenANegativeIntegerIsSpecified()
+        {
+            try
+            {
+                AutomaticLayout automaticLayout = new AutomaticLayout();
+                automaticLayout.RankSeparation = -100;
+                throw new TestFailedException();
+            }
+            catch (ArgumentException iae)
+            {
+                Assert.Equal("The rank separation must be a positive integer.", iae.Message);
+            }
+        }
+
+        [Fact]
+        public void Test_NodeSeparation_ThrowsAnException_WhenANegativeIntegerIsSpecified()
+        {
+            try
+            {
+                AutomaticLayout automaticLayout = new AutomaticLayout();
+                automaticLayout.NodeSeparation = -100;
+                throw new TestFailedException();
+            }
+            catch (ArgumentException iae)
+            {
+                Assert.Equal("The node separation must be a positive integer.", iae.Message);
+            }
+        }
+
+        [Fact]
+        public void Test_EdgeSeparation_ThrowsAnException_WhenANegativeIntegerIsSpecified()
+        {
+            try
+            {
+                AutomaticLayout automaticLayout = new AutomaticLayout();
+                automaticLayout.EdgeSeparation = -100;
+                throw new TestFailedException();
+            }
+            catch (ArgumentException iae)
+            {
+                Assert.Equal("The edge separation must be a positive integer.", iae.Message);
+            }
+        }
+        
+    }
+}

Structurizr.Core.Tests/View/ViewTests.cs

@@ -0,0 +1,46 @@
+using Xunit;
+
+namespace Structurizr.Core.Tests.View
+{
+    public class ViewTests : AbstractTestBase
+    {
+        [Fact]
+        public void Test_EnableAutomaticLayout_EnablesAutoLayoutWithSomeDefaultValues()
+        {
+            SystemLandscapeView view = new Workspace("", "").Views.CreateSystemLandscapeView("key", "Description");
+            view.EnableAutomaticLayout();
+
+            Assert.NotNull(view.AutomaticLayout);
+            Assert.Equal(RankDirection.TopBottom, view.AutomaticLayout.RankDirection);
+            Assert.Equal(300, view.AutomaticLayout.RankSeparation);
+            Assert.Equal(600, view.AutomaticLayout.NodeSeparation);
+            Assert.Equal(200, view.AutomaticLayout.EdgeSeparation);
+            Assert.False(view.AutomaticLayout.Vertices);
+        }
+
+        [Fact]
+        public void Test_DisableAutomaticLayout_DisablesAutoLayout()
+        {
+            SystemLandscapeView view = new Workspace("", "").Views.CreateSystemLandscapeView("key", "Description");
+            view.EnableAutomaticLayout();
+            Assert.NotNull(view.AutomaticLayout);
+
+            view.DisableAutomaticLayout();
+            Assert.Null(view.AutomaticLayout);
+        }
+
+        [Fact]
+        public void Test_EnableAutomaticLayout()
+        {
+            SystemLandscapeView view = new Workspace("", "").Views.CreateSystemLandscapeView("key", "Description");
+            view.EnableAutomaticLayout(RankDirection.LeftRight, 100, 200, 300, true);
+
+            Assert.NotNull(view.AutomaticLayout);
+            Assert.Equal(RankDirection.LeftRight, view.AutomaticLayout.RankDirection);
+            Assert.Equal(100, view.AutomaticLayout.RankSeparation);
+            Assert.Equal(200, view.AutomaticLayout.NodeSeparation);
+            Assert.Equal(300, view.AutomaticLayout.EdgeSeparation);
+            Assert.True(view.AutomaticLayout.Vertices);
+        }
+    }
+}

Structurizr.Core/View/AutomaticLayout.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Structurizr
+{
+    [DataContract]
+    public class AutomaticLayout
+    {
+
+        /// <summary>
+        /// The rank direction.
+        /// </summary>
+        [DataMember(Name = "rankDirection", EmitDefaultValue = false)]
+        public RankDirection RankDirection;
+
+        private int _rankSeparation;
+
+        /// <summary>
+        /// The rank separation (in pixels).
+        /// </summary>
+        [DataMember(Name = "rankSeparation", EmitDefaultValue = false)]
+        public int RankSeparation
+        {
+            get { return _rankSeparation; }
+
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentException("The rank separation must be a positive integer.");
+                }
+
+                _rankSeparation = value;
+            }
+        }
+
+        private int _nodeSeparation;
+        
+        [DataMember(Name = "nodeSeparation", EmitDefaultValue = false)]
+        public int NodeSeparation
+        {
+            get { return _nodeSeparation; }
+
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentException("The node separation must be a positive integer.");
+                }
+
+                _nodeSeparation = value;
+            }
+        }
+
+        private int _edgeSeparation;
+
+        [DataMember(Name = "edgeSeparation", EmitDefaultValue = false)]
+        public int EdgeSeparation
+        {
+            get { return _edgeSeparation; }
+
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentException("The edge separation must be a positive integer.");
+                }
+
+                _edgeSeparation = value;
+            }
+        }
+
+        /// <summary>
+        /// Whether the automatic layout algorithm should create vertices.
+        /// </summary>
+        [DataMember(Name = "vertices", EmitDefaultValue = true)]
+        public bool Vertices;
+
+        internal AutomaticLayout()
+        {
+        }
+
+        internal AutomaticLayout(RankDirection rankDirection, int rankSeparation, int nodeSeparation,
+            int edgeSeparation, bool vertices)
+        {
+            RankDirection = rankDirection;
+            RankSeparation = rankSeparation;
+            NodeSeparation = nodeSeparation;
+            EdgeSeparation = edgeSeparation;
+            Vertices = vertices;
+        }
+        
+    }
+
+}

Structurizr.Core/View/RankDirection.cs

@@ -0,0 +1,11 @@
+namespace Structurizr
+{
+    public enum RankDirection
+    {
+        TopBottom,
+        BottomTop,
+        LeftRight,
+        RightLeft
+    }
+    
+}

Structurizr.Core/View/View.cs

@@ -285,5 +285,37 @@ internal virtual RelationshipView FindRelationshipView(RelationshipView sourceRe
             return null;
         }
 
+        [DataMember(Name = "automaticLayout", EmitDefaultValue = false)]
+        public AutomaticLayout AutomaticLayout { get; internal set; }
+
+        /// <summary>
+        /// Enables automatic layout for this view, with some default settings.
+        /// </summary>
+        public void EnableAutomaticLayout()
+        {
+            EnableAutomaticLayout(RankDirection.TopBottom, 300, 600, 200, false);
+        }
+
+        /// <summary>
+        /// Enables the automatic layout for this view, with the specified settings.
+        /// </summary>
+        /// <param name="rankDirection">the rank direction</param>
+        /// <param name="rankSeparation">the separation between ranks (in pixels, a positive integer)</param>
+        /// <param name="nodeSeparation">the separation between nodes within the same rank (in pixels, a positive integer)</param>
+        /// <param name="edgeSeparation">the separation between edges (in pixels, a positive integer)</param>
+        /// <param name="vertices">whether vertices should be created during automatic layout</param>
+        public void EnableAutomaticLayout(RankDirection rankDirection, int rankSeparation, int nodeSeparation, int edgeSeparation, bool vertices)
+        {
+            AutomaticLayout = new AutomaticLayout(rankDirection, rankSeparation, nodeSeparation, edgeSeparation, vertices);
+        }
+
+        /// <summary>
+        /// Disables automatic layout for this view.
+        /// </summary>
+        public void DisableAutomaticLayout()
+        {
+            AutomaticLayout = null;
+        }
+        
     }
-}
+}

docs/changelog.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.9.4 (unreleased)
+
+- The automatic layout algorithm can now be configured on individual views.
+
 ## 0.9.3 (22nd November 2019)
 
 - Fixes a bug that allows relationships to be created between parents and children.