ADD Package

Author: Thundernerd

CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [1.0.0] - 2020-02-16
+### Added
+- Initial version

CHANGELOG.md.meta

@@ -0,0 +1,18 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace TNRD.Constraints
+{
+    public class Constrain
+    {
+        public static ConstrainedRect To(EditorWindow editorWindow)
+        {
+            return To(new Rect(Vector2.zero, editorWindow.position.size));
+        }
+
+        public static ConstrainedRect To(Rect rect)
+        {
+            return new ConstrainedRect(rect);
+        }
+    }
+}

Documentation~/ConstrainedRect.md

@@ -0,0 +1,66 @@
+using UnityEngine;
+
+namespace TNRD.Constraints
+{
+    public class ConstrainedRect
+    {
+        private readonly Rect parent;
+
+        public Constraint Top { get; }
+        public Constraint Bottom { get; }
+        public Constraint Left { get; }
+        public Constraint Right { get; }
+        public Constraint Width { get; }
+        public Constraint Height { get; }
+
+        public ConstrainedRect(Rect parent)
+        {
+            this.parent = parent;
+
+            Top = new Constraint(this, false);
+            Bottom = new Constraint(this, true);
+            Left = new Constraint(this, false);
+            Right = new Constraint(this, true);
+            Width = new Constraint(this, false);
+            Height = new Constraint(this, false);
+        }
+
+        public Rect Relative(float value)
+        {
+            return Relative(value, value, value, value);
+        }
+
+        public Rect Relative(float left, float top, float right, float bottom)
+        {
+            return Left.Relative(left)
+                .Top.Relative(top)
+                .Right.Relative(right)
+                .Bottom.Relative(bottom)
+                .ToRect();
+        }
+
+        public Rect ToRect()
+        {
+            var left = Left.Apply(parent.xMin);
+            var top = Top.Apply(parent.yMin);
+            var width = Width.IsSet ? Width.Apply(parent.width) : CalculateWidth();
+            var height = Height.IsSet ? Height.Apply(parent.height) : CalculateHeight();
+
+            return new Rect(left, top, width, height);
+        }
+
+        private float CalculateWidth()
+        {
+            var right = Right.Apply(parent.xMax);
+            var left = Left.Apply(parent.xMin);
+            return right - left;
+        }
+
+        private float CalculateHeight()
+        {
+            var bottom = Bottom.Apply(parent.yMax);
+            var top = Top.Apply(parent.yMin);
+            return bottom - top;
+        }
+    }
+}

Editor.meta

@@ -0,0 +1,66 @@
+using System;
+
+namespace TNRD.Constraints
+{
+    public class Constraint
+    {
+        private enum ConstrainMode
+        {
+            NotSet,
+            Relative,
+            Absolute,
+            Percentage
+        }
+
+        private readonly ConstrainedRect parent;
+        private ConstrainMode mode;
+        private bool negateValue;
+        private float value;
+
+        private float Value => negateValue ? -value : value;
+
+        public bool IsSet => mode != ConstrainMode.NotSet;
+
+        public Constraint(ConstrainedRect parent, bool negateValue)
+        {
+            this.parent = parent;
+            this.negateValue = negateValue;
+        }
+
+        public ConstrainedRect Relative(float value)
+        {
+            mode = ConstrainMode.Relative;
+            this.value = value;
+            return parent;
+        }
+
+        public ConstrainedRect Absolute(float value)
+        {
+            mode = ConstrainMode.Absolute;
+            this.value = value;
+            return parent;
+        }
+
+        public ConstrainedRect Percentage(float value)
+        {
+            mode = ConstrainMode.Percentage;
+            this.value = value;
+            return parent;
+        }
+
+        internal float Apply(float value)
+        {
+            switch (mode)
+            {
+                case ConstrainMode.Relative:
+                    return value + Value;
+                case ConstrainMode.Absolute:
+                    return this.value; // We don't want to negate the value here
+                case ConstrainMode.Percentage:
+                    return value * Value;
+            }
+
+            return value;
+        }
+    }
+}