batframework 1.0.8a3__py3-none-any.whl → 1.0.8a6__py3-none-any.whl

batFramework/gui/constraints/constraints.py

@@ -4,9 +4,12 @@ import pygame
 
 
 class Constraint:
-    def __init__(self, name="Constraint", priority=0):
+    def __init__(self, name:str|None=None, priority=0):
         self.priority = priority
-        self.name = name
+        self.name = name if name is not None else self.__class__.__name__
+
+    def on_removal(self,child_widget: Widget)->None:
+        pass
 
     def set_priority(self, priority) -> "Constraint":
         self.priority = priority
@@ -26,35 +29,117 @@ class Constraint:
 
     def apply_constraint(self, parent_widget: Widget, child_widget: Widget):
         raise NotImplementedError("Subclasses must implement apply_constraint method")
-
+    
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return other.name == self.name
 
 class MinWidth(Constraint):
     def __init__(self, width: float):
-        super().__init__(name="min_width")
+        super().__init__()
         self.min_width = width
 
+    def on_removal(self, child_widget: Widget) -> None:
+            child_widget.set_autoresize_w(False)
+
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width >= self.min_width
+        res =  child_widget.rect.width >= self.min_width
+        if not res:
+            child_widget.set_autoresize_w(False)
+        return res
 
     def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_w(True)
         child_widget.set_size((self.min_width, None))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.min_width == self.min_width
+        )
 
 class MinHeight(Constraint):
     def __init__(self, height: float):
-        super().__init__(name="min_height")
+        super().__init__()
         self.min_height = height
 
+    def on_removal(self, child_widget: Widget) -> None:
+            child_widget.set_autoresize_h(False)
+
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.h >= self.min_height
+        res = child_widget.rect.h >= self.min_height
+        if not res:
+            child_widget.set_autoresize_w(False)
+        return res
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_size((None, self.min_height))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.min_height == self.min_height
+        )
+
+class MaxWidth(Constraint):
+    def __init__(self, width: float):
+        super().__init__()
+        self.max_width = width
+
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize_w(False)
+
+    def evaluate(self, parent_widget, child_widget):
+        res = child_widget.rect.width <= self.max_width
+        if not res:
+            child_widget.set_autoresize_w(False)
+        return res
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_w(True)
+        current_height = child_widget.rect.height
+        child_widget.set_size((self.max_width, current_height))
+
+    def __eq__(self, other: "Constraint") -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return other.max_width == self.max_width
+
+
+class MaxHeight(Constraint):
+    def __init__(self, height: float):
+        super().__init__()
+        self.max_height = height
+
+    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.height <= self.max_height
+        if not res:
+            child_widget.set_autoresize_h(False)
+        return res
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_h(True)
+        current_width = child_widget.rect.width
+        child_widget.set_size((current_width, self.max_height))
+
+    def __eq__(self, other: "Constraint") -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return other.max_height == self.max_height
+
+
 
 class CenterX(Constraint):
     def __init__(self):
-        super().__init__(name="centerx")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -69,7 +154,7 @@ class CenterX(Constraint):
 
 class CenterY(Constraint):
     def __init__(self):
-        super().__init__(name="centery")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -84,7 +169,7 @@ class CenterY(Constraint):
 
 class Center(Constraint):
     def __init__(self):
-        super().__init__(name="center")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -99,10 +184,13 @@ class Center(Constraint):
 
 class PercentageWidth(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_width")
+        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)
+
     def __str__(self) -> str:
         return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
 
@@ -124,13 +212,24 @@ class PercentageWidth(Constraint):
             (round(parent_widget.get_padded_width() * self.percentage), None)
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
+
 
 class PercentageHeight(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_height")
+        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)
+
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.height == round(
             parent_widget.get_padded_height() * self.percentage
@@ -151,25 +250,40 @@ class PercentageHeight(Constraint):
             (None, round(parent_widget.get_padded_height() * self.percentage))
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
 
 class FillX(PercentageWidth):
     def __init__(self, keep_autoresize: bool = False):
         super().__init__(1, keep_autoresize)
-        self.name = "fill_x"
+        self.name = "FillX"
 
+    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)
-        self.name = "fill_y"
+        self.name = "FillY"
+
+    def __eq__(self, other: Constraint) -> bool:
+        return Constraint.__eq__(self,other)
 
 
 class PercentageRectHeight(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_rect_height")
+        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)
+
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.height == round(
             parent_widget.rect.height * self.percentage
@@ -190,13 +304,23 @@ class PercentageRectHeight(Constraint):
             (None, round(parent_widget.rect.height * self.percentage))
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
 
 class PercentageRectWidth(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_rect_width")
+        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)
+
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.width == round(
             parent_widget.rect.width * self.percentage
@@ -215,6 +339,13 @@ class PercentageRectWidth(Constraint):
             child_widget.set_autoresize_w(False)
         child_widget.set_size((round(parent_widget.rect.width * self.percentage), None))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
 
 class FillRectX(PercentageRectWidth):
     def __init__(self, keep_autoresize: bool = False):
@@ -235,7 +366,7 @@ class AspectRatio(Constraint):
         reference_axis: bf.axis = bf.axis.HORIZONTAL,
         keep_autoresize=False,
     ):
-        super().__init__(name="aspect_ratio")
+        super().__init__()
         self.ref_axis: bf.axis = reference_axis
         self.keep_autoresize: bool = keep_autoresize
 
@@ -250,11 +381,16 @@ class AspectRatio(Constraint):
         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.w / child_widget.rect.h
-        if self.ref_axis == bf.axis.VERTICAL:
             return self.ratio == child_widget.rect.h / child_widget.rect.w
+        if self.ref_axis == bf.axis.VERTICAL:
+            return self.ratio == child_widget.rect.w / child_widget.rect.h
+
 
     def apply_constraint(self, parent_widget, child_widget):
 
@@ -262,7 +398,7 @@ class AspectRatio(Constraint):
             if child_widget.autoresize_w:
                 if self.keep_autoresize:
                     print(
-                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                        f"WARNING: Constraint on {str(child_widget)} can't resize, autoresize set to True"
                     )
                     return
                 child_widget.set_autoresize_w(False)
@@ -272,22 +408,30 @@ class AspectRatio(Constraint):
             if child_widget.autoresize_h:
                 if self.keep_autoresize:
                     print(
-                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                        f"WARNING: Constraint on {str(child_widget)} can't resize, autoresize set to True"
                     )
                     return
                 child_widget.set_autoresize_h(False)
-            print("HERE")
+
             child_widget.set_size((None, child_widget.rect.w * self.ratio))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.ratio == self.ratio and
+            other.ref_axis == self.ref_axis
+        )
 
 class AnchorBottom(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_bottom")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
-            child_widget.rect.top
-            == parent_widget.get_padded_bottom() - child_widget.rect.h
+            child_widget.rect.bottom
+            == parent_widget.get_padded_bottom()
         )
 
     def apply_constraint(self, parent_widget, child_widget):
@@ -295,40 +439,34 @@ class AnchorBottom(Constraint):
             child_widget.rect.x, parent_widget.get_padded_bottom() - child_widget.rect.h
         )
 
-
-class AnchorBottom(Constraint):
+class AnchorTop(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_bottom")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
-        return (
-            child_widget.rect.top
-            == parent_widget.get_padded_bottom() - child_widget.rect.h
-        )
+        return (child_widget.rect.top == parent_widget.get_padded_top())
 
     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.set_position(child_widget.rect.x, parent_widget.get_padded_top())
 
 
 class AnchorTopRight(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_topright")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.topright == parent_widget.get_padded_rect().topright
 
     def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            parent_widget.get_padded_top(),
-        )
+        # print("before",child_widget.rect.topright, parent_widget.get_padded_rect().topright)
+        topright = parent_widget.get_padded_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)
 
 
 class AnchorBottomRight(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_bottomright")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -336,15 +474,17 @@ class AnchorBottomRight(Constraint):
         )
 
     def apply_constraint(self, parent_widget, child_widget):
+        bottomright =  parent_widget.get_padded_rect().bottomright
+
         child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            parent_widget.get_padded_bottom() - child_widget.rect.h,
+            bottomright[0] - child_widget.rect.w,
+            bottomright[1] - child_widget.rect.h,
         )
 
 
 class AnchorRight(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_right")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.right == parent_widget.get_padded_right()
@@ -358,7 +498,7 @@ class AnchorRight(Constraint):
 
 class AnchorLeft(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_left")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.left == parent_widget.get_padded_left()
@@ -371,7 +511,7 @@ class AnchorLeft(Constraint):
 
 class MarginBottom(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_bottom")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -385,10 +525,17 @@ class MarginBottom(Constraint):
             parent_widget.get_padded_bottom() - child_widget.rect.h - self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class MarginTop(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_top")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -399,10 +546,17 @@ class MarginTop(Constraint):
             child_widget.rect.x, parent_widget.get_padded_top() + self.margin
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class MarginLeft(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_left")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -414,10 +568,17 @@ class MarginLeft(Constraint):
                 parent_widget.get_padded_left() + self.margin, child_widget.rect.y
             )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class MarginRight(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_right")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -429,10 +590,17 @@ class MarginRight(Constraint):
             child_widget.rect.y,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginBottom(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_bottom")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -450,10 +618,17 @@ class PercentageMarginBottom(Constraint):
             - parent_widget.get_padded_height() * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginTop(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_top")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -470,10 +645,17 @@ class PercentageMarginTop(Constraint):
             + parent_widget.get_padded_height() * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginLeft(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_left")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -491,10 +673,17 @@ class PercentageMarginLeft(Constraint):
                 child_widget.rect.y,
             )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginRight(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_right")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -512,10 +701,17 @@ class PercentageMarginRight(Constraint):
             child_widget.rect.y,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginBottom(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_bottom")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -532,10 +728,17 @@ class PercentageRectMarginBottom(Constraint):
             - parent_widget.rect.height * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginTop(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_top")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -550,10 +753,17 @@ class PercentageRectMarginTop(Constraint):
             parent_widget.rect.top + parent_widget.rect.height * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginLeft(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_left")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -569,10 +779,17 @@ class PercentageRectMarginLeft(Constraint):
                 child_widget.rect.y,
             )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginRight(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_right")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -588,3 +805,11 @@ class PercentageRectMarginRight(Constraint):
             - parent_widget.rect.width * self.margin,
             child_widget.rect.y,
         )
+
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )