batframework 1.0.9a7__py3-none-any.whl → 1.0.9a8__py3-none-any.whl

batFramework/gui/constraints/constraints.py

@@ -1,3 +1,4 @@
+from abc import ABC, abstractmethod
 from ..widget import Widget
 import batFramework as bf
 import pygame
@@ -7,11 +8,22 @@ class Constraint:
     def __init__(self, name:str|None=None, priority=0):
         self.priority = priority
         self.name = name if name is not None else self.__class__.__name__
+        self.old_autoresize_w = None
+        self.old_autoresize_h = None
+        self.affects_size : bool = False
+        self.affects_position : bool = False
+
 
     def on_removal(self,child_widget: Widget)->None:
-        pass
+        child_widget.set_autoresize_h(self.old_autoresize_h)
+        child_widget.set_autoresize_w(self.old_autoresize_w)
+
 
     def set_priority(self, priority) -> "Constraint":
+        """
+        Highest priority is used if 2 constraints are in conflict
+        Default is 0
+        """
         self.priority = priority
         return self
 
@@ -22,6 +34,11 @@ class Constraint:
         raise NotImplementedError("Subclasses must implement evaluate method")
 
     def apply(self, parent_widget: Widget, child_widget: Widget = None) -> bool:
+        if self.old_autoresize_h is None:
+            self.old_autoresize_h = child_widget.autoresize_h
+        if self.old_autoresize_w is None:
+            self.old_autoresize_w = child_widget.autoresize_w
+
         if not self.evaluate(parent_widget, child_widget):
             self.apply_constraint(parent_widget, child_widget)
             return False
@@ -39,18 +56,14 @@ class MinWidth(Constraint):
     def __init__(self, width: float):
         super().__init__()
         self.min_width = width
+        self.affects_size = True
 
-    def on_removal(self, child_widget: Widget) -> None:
-            return
-            # child_widget.set_autoresize_w(False)
 
     def evaluate(self, parent_widget, child_widget):
-        res =  child_widget.rect.width >= self.min_width
-        # if not res:
-            # child_widget.set_autoresize_w(False)
-        return res
+        return child_widget.rect.width >= self.min_width
 
     def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_w(False)
         child_widget.set_size((self.min_width, None))
 
     def __eq__(self,other:"Constraint")->bool:
@@ -65,17 +78,15 @@ class MinHeight(Constraint):
     def __init__(self, height: float):
         super().__init__()
         self.min_height = height
+        self.affects_size = True
 
-    def on_removal(self, child_widget: Widget) -> None:
-            child_widget.set_autoresize_h(False)
 
     def evaluate(self, parent_widget, child_widget):
-        res = child_widget.rect.h >= self.min_height
-        if not res:
-            child_widget.set_autoresize_w(False)
-        return res
+        return child_widget.rect.h >= self.min_height
+        
 
     def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_h(False)
         child_widget.set_size((None, self.min_height))
 
     def __eq__(self,other:"Constraint")->bool:
@@ -90,6 +101,7 @@ class MaxWidth(Constraint):
     def __init__(self, width: float):
         super().__init__()
         self.max_width = width
+        self.affects_size = True
 
     def on_removal(self, child_widget: Widget) -> None:
         child_widget.set_autoresize_w(False)
@@ -115,6 +127,7 @@ class MaxHeight(Constraint):
     def __init__(self, height: float):
         super().__init__()
         self.max_height = height
+        self.affects_size = True
 
     def on_removal(self, child_widget: Widget) -> None:
         child_widget.set_autoresize_h(False)
@@ -140,76 +153,69 @@ class MaxHeight(Constraint):
 class CenterX(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
-            int(child_widget.rect.centerx - parent_widget.get_padded_center()[0]) == 0
+            child_widget.rect.centerx - parent_widget.get_inner_center()[0] == 0
         )
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_center(
-            parent_widget.get_padded_center()[0], child_widget.rect.centery
+            parent_widget.get_inner_center()[0], child_widget.rect.centery
         )
 
 
 class CenterY(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
-            int(child_widget.rect.centery - parent_widget.get_padded_center()[1]) == 0
+            child_widget.rect.centery - parent_widget.get_inner_center()[1] == 0
         )
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_center(
-            child_widget.rect.centerx, parent_widget.get_padded_center()[1]
+            child_widget.rect.centerx, parent_widget.get_inner_center()[1]
         )
 
 
 class Center(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
-            int(child_widget.rect.centerx - parent_widget.get_padded_center()[0]) == 0
-            and int(child_widget.rect.centery - parent_widget.get_padded_center()[1])
-            == 0
+            child_widget.rect.centerx - parent_widget.get_inner_center()[0] == 0
+            and child_widget.rect.centery - parent_widget.get_inner_center()[1] == 0
         )
 
     def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_center(*parent_widget.get_padded_center())
+        child_widget.set_center(*parent_widget.get_inner_center())
 
 
 class PercentageWidth(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = False):
+    def __init__(self, percentage: float):
         super().__init__()
         self.percentage: float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-
-    def on_removal(self, child_widget: Widget) -> None:
-        child_widget.set_autoresize_w(True)
+        self.affects_size = True
 
     def __str__(self) -> str:
-        return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
+        return f"{super().__str__()}.[{self.percentage*100}%]"
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.width == round(
-            parent_widget.get_padded_width() * self.percentage
+            parent_widget.get_inner_width() * self.percentage
         )
 
     def apply_constraint(self, parent_widget, child_widget):
         if child_widget.autoresize_w:
-            if self.keep_autoresize:
-                print(
-                    f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
-                )
-                return
             child_widget.set_autoresize_w(False)
-
         child_widget.set_size(
-            (round(parent_widget.get_padded_width() * self.percentage), None)
+            (round(parent_widget.get_inner_width() * self.percentage), None)
         )
 
     def __eq__(self,other:"Constraint")->bool:
@@ -222,32 +228,25 @@ class PercentageWidth(Constraint):
 
 
 class PercentageHeight(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = False):
+    def __init__(self, percentage: float):
         super().__init__()
         self.percentage: float = percentage
-        self.keep_autoresize: bool = keep_autoresize
+        self.affects_size = True
 
-    def on_removal(self, child_widget: Widget) -> None:
-        child_widget.set_autoresize_h(True)
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.height == round(
-            parent_widget.get_padded_height() * self.percentage
+            parent_widget.get_inner_height() * self.percentage
         )
 
     def __str__(self) -> str:
-        return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
+        return f"{super().__str__()}.[{self.percentage*100}%]"
 
     def apply_constraint(self, parent_widget, child_widget):
         if child_widget.autoresize_h:
-            if self.keep_autoresize:
-                print(
-                    f"WARNING: Constraint on {child_widget} can't resize, autoresize set to True"
-                )
-                return
             child_widget.set_autoresize_h(False)
         child_widget.set_size(
-            (None, round(parent_widget.get_padded_height() * self.percentage))
+            (None, round(parent_widget.get_inner_height() * self.percentage))
         )
 
     def __eq__(self,other:"Constraint")->bool:
@@ -259,30 +258,29 @@ class PercentageHeight(Constraint):
         )
 
 class FillX(PercentageWidth):
-    def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1, keep_autoresize)
+    def __init__(self):
+        super().__init__(1)
         self.name = "FillX"
+        self.affects_size = True
 
     def __eq__(self, other: Constraint) -> bool:
         return Constraint.__eq__(self,other)
 
 class FillY(PercentageHeight):
-    def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1, keep_autoresize)
+    def __init__(self):
+        super().__init__(1)
         self.name = "FillY"
+        self.affects_size = True
 
     def __eq__(self, other: Constraint) -> bool:
         return Constraint.__eq__(self,other)
 
 
 class PercentageRectHeight(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = False):
+    def __init__(self, percentage: float):
         super().__init__()
         self.percentage: float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-
-    def on_removal(self, child_widget: Widget) -> None:
-        child_widget.set_autoresize_h(True)
+        self.affects_size = True
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.height == round(
@@ -290,15 +288,10 @@ class PercentageRectHeight(Constraint):
         )
 
     def __str__(self) -> str:
-        return f"{super().__str__()}.[{self.percentage*100}%, keep_autoresize={self.keep_autoresize}]"
+        return f"{super().__str__()}.[{self.percentage*100}%]"
 
     def apply_constraint(self, parent_widget, child_widget):
         if child_widget.autoresize_h:
-            if self.keep_autoresize:
-                print(
-                    f"WARNING: Constraint on {child_widget} can't resize, autoresize set to True"
-                )
-                return
             child_widget.set_autoresize_h(False)
         child_widget.set_size(
             (None, round(parent_widget.rect.height * self.percentage))
@@ -313,10 +306,10 @@ class PercentageRectHeight(Constraint):
         )
 
 class PercentageRectWidth(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = False):
+    def __init__(self, percentage: float):
         super().__init__()
         self.percentage: float = percentage
-        self.keep_autoresize: bool = keep_autoresize
+        self.affects_size = True
 
     def on_removal(self, child_widget: Widget) -> None:
         child_widget.set_autoresize_w(True)
@@ -327,15 +320,10 @@ class PercentageRectWidth(Constraint):
         )
 
     def __str__(self) -> str:
-        return f"{super().__str__()}.[{self.percentage*100}%, keep_autoresize={self.keep_autoresize}]"
+        return f"{super().__str__()}.[{self.percentage*100}%]"
 
     def apply_constraint(self, parent_widget, child_widget):
         if child_widget.autoresize_w:
-            if self.keep_autoresize:
-                print(
-                    f"WARNING: Constraint on {child_widget} can't resize, autoresize set to True"
-                )
-                return
             child_widget.set_autoresize_w(False)
         child_widget.set_size((round(parent_widget.rect.width * self.percentage), None))
 
@@ -348,15 +336,17 @@ class PercentageRectWidth(Constraint):
         )
 
 class FillRectX(PercentageRectWidth):
-    def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1, keep_autoresize)
+    def __init__(self):
+        super().__init__(1)
         self.name = "fill_rect_x"
+        self.affects_size = True
 
 
 class FillRectY(PercentageRectHeight):
-    def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1, keep_autoresize)
+    def __init__(self):
+        super().__init__(1)
         self.name = "fill_rect_y"
+        self.affects_size = True
 
 
 class AspectRatio(Constraint):
@@ -364,57 +354,48 @@ class AspectRatio(Constraint):
         self,
         ratio: int | float | pygame.rect.FRectType = 1,
         reference_axis: bf.axis = bf.axis.HORIZONTAL,
-        keep_autoresize=False,
     ):
         super().__init__()
         self.ref_axis: bf.axis = reference_axis
-        self.keep_autoresize: bool = keep_autoresize
+        self.affects_size = True
 
         if isinstance(ratio, float | int):
             self.ratio = ratio
         elif isinstance(ratio, pygame.rect.FRect):
             self.ratio = (
-                (ratio.w / ratio.h)
+                round(ratio.w / ratio.h,2)
                 if reference_axis == bf.axis.HORIZONTAL
-                else (ratio.h / ratio.w)
+                else round(ratio.h / ratio.w,2)
             )
         else:
             raise TypeError(f"Ratio must be float or FRect")
 
-    def on_removal(self, child_widget: Widget) -> None:
-        child_widget.set_autoresize(True)
 
 
     def evaluate(self, parent_widget, child_widget):
         if self.ref_axis == bf.axis.HORIZONTAL:
-            return self.ratio == child_widget.rect.h / child_widget.rect.w
+            return self.ratio == round(child_widget.rect.h / child_widget.rect.w,2)
         if self.ref_axis == bf.axis.VERTICAL:
-            return self.ratio == child_widget.rect.w / child_widget.rect.h
+            return self.ratio == round(child_widget.rect.w / child_widget.rect.h,2)
 
 
     def apply_constraint(self, parent_widget, child_widget):
 
         if self.ref_axis == bf.axis.VERTICAL:
             if child_widget.autoresize_w:
-                if self.keep_autoresize:
-                    print(
-                        f"WARNING: Constraint on {str(child_widget)} can't resize, autoresize set to True"
-                    )
-                    return
                 child_widget.set_autoresize_w(False)
             child_widget.set_size((child_widget.rect.h * self.ratio, None))
 
         if self.ref_axis == bf.axis.HORIZONTAL:
             if child_widget.autoresize_h:
-                if self.keep_autoresize:
-                    print(
-                        f"WARNING: Constraint on {str(child_widget)} can't resize, autoresize set to True"
-                    )
-                    return
                 child_widget.set_autoresize_h(False)
 
             child_widget.set_size((None, child_widget.rect.w * self.ratio))
 
+    def __str__(self) -> str:
+        return f"{self.name.upper()}[ratio = {self.ratio}, ref = {'Vertical' if self.ref_axis == bf.axis.VERTICAL else 'Horizontal'}]"
+
+
     def __eq__(self,other:"Constraint")->bool:
         if not isinstance(other,self.__class__):
             return False
@@ -427,54 +408,69 @@ class AspectRatio(Constraint):
 class AnchorBottom(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
             child_widget.rect.bottom
-            == parent_widget.get_padded_bottom()
+            == parent_widget.get_inner_bottom()
         )
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
-            child_widget.rect.x, parent_widget.get_padded_bottom() - child_widget.rect.h
+            child_widget.rect.x, parent_widget.get_inner_bottom() - child_widget.rect.h
         )
 
 class AnchorTop(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return (child_widget.rect.top == parent_widget.get_padded_top())
+        return (child_widget.rect.top == parent_widget.get_inner_top())
 
     def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(child_widget.rect.x, parent_widget.get_padded_top())
+        child_widget.set_position(child_widget.rect.x, parent_widget.get_inner_top())
 
 
 class AnchorTopRight(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.topright == parent_widget.get_padded_rect().topright
+        return child_widget.rect.topright == parent_widget.get_inner_rect().topright
 
     def apply_constraint(self, parent_widget, child_widget):
-        # print("before",child_widget.rect.topright, parent_widget.get_padded_rect().topright)
-        topright = parent_widget.get_padded_rect().topright
+        # print("before",child_widget.rect.topright, parent_widget.get_inner_rect().topright)
+        topright = parent_widget.get_inner_rect().topright
         child_widget.set_position(topright[0] - child_widget.rect.w,topright[1])
-        # print("after",child_widget.rect.topright, parent_widget.get_padded_rect().topright)
+        # print("after",child_widget.rect.topright, parent_widget.get_inner_rect().topright)
+
+class AnchorTopLeft(Constraint):
+    def __init__(self):
+        super().__init__()
+        self.affects_position = True
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.topleft == parent_widget.get_inner_rect().topleft
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(*parent_widget.get_inner_rect().topleft)
 
 
 class AnchorBottomRight(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
-            child_widget.rect.bottomright == parent_widget.get_padded_rect().bottomright
+            child_widget.rect.bottomright == parent_widget.get_inner_rect().bottomright
         )
 
     def apply_constraint(self, parent_widget, child_widget):
-        bottomright =  parent_widget.get_padded_rect().bottomright
+        bottomright =  parent_widget.get_inner_rect().bottomright
 
         child_widget.set_position(
             bottomright[0] - child_widget.rect.w,
@@ -485,27 +481,29 @@ class AnchorBottomRight(Constraint):
 class AnchorRight(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.right == parent_widget.get_padded_right()
+        return child_widget.rect.right == parent_widget.get_inner_right()
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            child_widget.rect.top,
+            parent_widget.get_inner_right() - child_widget.rect.w,
+            None,
         )
 
 
 class AnchorLeft(Constraint):
     def __init__(self):
         super().__init__()
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.left == parent_widget.get_padded_left()
+        return child_widget.rect.left == parent_widget.get_inner_left()
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
-            parent_widget.get_padded_left(), child_widget.rect.top
+            parent_widget.get_inner_left(), None
         )
 
 
@@ -513,16 +511,17 @@ class MarginBottom(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
-            child_widget.rect.bottom == parent_widget.get_padded_bottom() - self.margin
+            child_widget.rect.bottom == parent_widget.get_inner_bottom() - self.margin
         )
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
             child_widget.rect.x,
-            parent_widget.get_padded_bottom() - child_widget.rect.h - self.margin,
+            parent_widget.get_inner_bottom() - child_widget.rect.h - self.margin,
         )
 
     def __eq__(self,other:"Constraint")->bool:
@@ -537,13 +536,14 @@ class MarginTop(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.top == parent_widget.get_padded_top() + self.margin
+        return child_widget.rect.top == parent_widget.get_inner_top() + self.margin
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
-            child_widget.rect.x, parent_widget.get_padded_top() + self.margin
+            child_widget.rect.x, parent_widget.get_inner_top() + self.margin
         )
 
     def __eq__(self,other:"Constraint")->bool:
@@ -558,14 +558,15 @@ class MarginLeft(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.left == parent_widget.get_padded_left() + self.margin
+        return child_widget.rect.left == parent_widget.get_inner_left() + self.margin
 
     def apply_constraint(self, parent_widget, child_widget):
         if not self.evaluate(parent_widget, child_widget):
             child_widget.set_position(
-                parent_widget.get_padded_left() + self.margin, child_widget.rect.y
+                parent_widget.get_inner_left() + self.margin, child_widget.rect.y
             )
 
     def __eq__(self,other:"Constraint")->bool:
@@ -580,13 +581,14 @@ class MarginRight(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.right == parent_widget.get_padded_right() - self.margin
+        return child_widget.rect.right == parent_widget.get_inner_right() - self.margin
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w - self.margin,
+            parent_widget.get_inner_right() - child_widget.rect.w - self.margin,
             child_widget.rect.y,
         )
 
@@ -602,6 +604,7 @@ class RectMarginBottom(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -626,6 +629,7 @@ class RectMarginTop(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.top == parent_widget.rect.top + self.margin
@@ -647,6 +651,7 @@ class RectMarginLeft(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.left == parent_widget.rect.left + self.margin
@@ -669,6 +674,7 @@ class RectMarginRight(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.right == parent_widget.rect.right - self.margin
@@ -691,20 +697,22 @@ class PercentageMarginBottom(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return (
+        return abs(
             child_widget.rect.bottom
-            == parent_widget.get_padded_top()
-            + parent_widget.get_padded_height() * self.margin
-        )
+            - (
+                parent_widget.get_inner_bottom()- 
+                parent_widget.get_inner_height() * self.margin)
+        ) < 0.01
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
             child_widget.rect.x,
-            parent_widget.get_padded_bottom()
+            parent_widget.get_inner_bottom()
             - child_widget.rect.h
-            - parent_widget.get_padded_height() * self.margin,
+            - parent_widget.get_inner_height() * self.margin,
         )
 
     def __eq__(self,other:"Constraint")->bool:
@@ -719,19 +727,21 @@ class PercentageMarginTop(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
-        return (
+        return abs(
             child_widget.rect.top
-            == parent_widget.get_padded_top()
-            + parent_widget.get_padded_height() * self.margin
-        )
+            - (
+                parent_widget.get_inner_top()+ 
+                parent_widget.get_inner_height() * self.margin)
+        ) < 0.01
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
             child_widget.rect.x,
-            parent_widget.get_padded_top()
-            + parent_widget.get_padded_height() * self.margin,
+            parent_widget.get_inner_top()
+            + parent_widget.get_inner_height() * self.margin,
         )
 
     def __eq__(self,other:"Constraint")->bool:
@@ -746,19 +756,20 @@ class PercentageMarginLeft(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
             child_widget.rect.left
-            == parent_widget.get_padded_left()
-            + parent_widget.get_padded_width() * self.margin
+            == parent_widget.get_inner_left()
+            + parent_widget.get_inner_width() * self.margin
         )
 
     def apply_constraint(self, parent_widget, child_widget):
         if not self.evaluate(parent_widget, child_widget):
             child_widget.set_position(
-                parent_widget.get_padded_left()
-                + parent_widget.get_padded_width() * self.margin,
+                parent_widget.get_inner_left()
+                + parent_widget.get_inner_width() * self.margin,
                 child_widget.rect.y,
             )
 
@@ -774,19 +785,20 @@ class PercentageMarginRight(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
             child_widget.rect.right
-            == parent_widget.get_padded_right()
-            - parent_widget.get_padded_width() * self.margin
+            == parent_widget.get_inner_right()
+            - parent_widget.get_inner_width() * self.margin
         )
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
-            parent_widget.get_padded_right()
+            parent_widget.get_inner_right()
             - child_widget.rect.w
-            - parent_widget.get_padded_width() * self.margin,
+            - parent_widget.get_inner_width() * self.margin,
             child_widget.rect.y,
         )
 
@@ -802,6 +814,7 @@ class PercentageRectMarginBottom(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -829,6 +842,7 @@ class PercentageRectMarginTop(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -854,6 +868,7 @@ class PercentageRectMarginLeft(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -880,6 +895,7 @@ class PercentageRectMarginRight(Constraint):
     def __init__(self, margin: float):
         super().__init__()
         self.margin = margin
+        self.affects_position = True
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -902,3 +918,63 @@ class PercentageRectMarginRight(Constraint):
             other.name == self.name and
             other.margin == self.margin
         )
+
+
+
+
+class Grow(Constraint, ABC):
+
+    @abstractmethod
+    def evaluate(self, parent_widget, child_widget):
+        pass
+
+    @abstractmethod
+    def apply_constraint(self, parent_widget, child_widget):
+        pass
+
+    def __eq__(self, other: "Constraint") -> bool:
+        return isinstance(other, self.__class__)
+
+
+class GrowH(Grow):
+    def __init__(self):
+        super().__init__()
+        self.affects_size = True
+
+    def evaluate(self, parent_widget, child_widget):
+        siblings = [s for s in parent_widget.children if s != child_widget]
+        sibling_width = sum(s.rect.w for s in siblings)
+        return abs(parent_widget.get_inner_width() - (child_widget.rect.w + sibling_width)) == 0
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_w(False)
+        siblings = [s for s in parent_widget.children if s != child_widget]
+        sibling_width = sum(s.rect.w for s in siblings)
+        # print(parent_widget.get_inner_width() - sibling_width," is new size")
+        if hasattr(parent_widget,"layout"):
+            w = parent_widget.layout.get_free_space()[0]
+        else:
+            w = parent_widget.get_inner_width()
+        child_widget.set_size((w - sibling_width, None))
+
+
+class GrowV(Grow):
+    def __init__(self):
+        super().__init__()
+        self.affects_size = True
+
+    def evaluate(self, parent_widget, child_widget):
+        siblings = [s for s in parent_widget.children if s != child_widget]
+        sibling_height = sum(s.rect.h for s in siblings)
+        return abs(parent_widget.get_inner_height() - (child_widget.rect.h + sibling_height)) == 0
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_h(False)
+        siblings = [s for s in parent_widget.children if s != child_widget]
+        sibling_height = sum(s.rect.h for s in siblings)
+        if hasattr(parent_widget,"layou"):
+            h = parent_widget.layout.get_free_space()[1]
+        else:
+            h = parent_widget.get_inner_height()
+    
+        child_widget.set_size((None, h- sibling_height))