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

batFramework/gui/constraints/constraints.py

@@ -37,7 +37,7 @@ class MinWidth(Constraint):
         return child_widget.rect.width >= self.min_width
 
     def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_size((self.min_width,None))
+        child_widget.set_size((self.min_width, None))
 
 
 class MinHeight(Constraint):
@@ -57,12 +57,14 @@ class CenterX(Constraint):
         super().__init__(name="centerx")
 
     def evaluate(self, parent_widget, child_widget):
-        return int(child_widget.rect.centerx - parent_widget.get_padded_center()[0]) == 0 
+        return (
+            int(child_widget.rect.centerx - parent_widget.get_padded_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_padded_center()[0], child_widget.rect.centery
+        )
 
 
 class CenterY(Constraint):
@@ -70,12 +72,14 @@ class CenterY(Constraint):
         super().__init__(name="centery")
 
     def evaluate(self, parent_widget, child_widget):
-        return int(child_widget.rect.centery - parent_widget.get_padded_center()[1]) == 0 
+        return (
+            int(child_widget.rect.centery - parent_widget.get_padded_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_padded_center()[1]
+        )
 
 
 class Center(Constraint):
@@ -83,8 +87,11 @@ class Center(Constraint):
         super().__init__(name="center")
 
     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
+        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
+        )
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_center(*parent_widget.get_padded_center())
@@ -114,10 +121,10 @@ class PercentageWidth(Constraint):
             child_widget.set_autoresize_w(False)
 
         child_widget.set_size(
-            (
-                round(parent_widget.get_padded_width() * self.percentage),None)
+            (round(parent_widget.get_padded_width() * self.percentage), None)
         )
 
+
 class PercentageHeight(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
         super().__init__(name="percentage_height")
@@ -125,7 +132,9 @@ class PercentageHeight(Constraint):
         self.keep_autoresize: bool = keep_autoresize
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == round(parent_widget.get_padded_height() * self.percentage)
+        return child_widget.rect.height == round(
+            parent_widget.get_padded_height() * self.percentage
+        )
 
     def __str__(self) -> str:
         return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
@@ -133,68 +142,90 @@ class PercentageHeight(Constraint):
     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")
+                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)))
+        child_widget.set_size(
+            (None, round(parent_widget.get_padded_height() * self.percentage))
+        )
+
 
 class FillX(PercentageWidth):
     def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1,keep_autoresize)
+        super().__init__(1, keep_autoresize)
         self.name = "fill_x"
 
+
 class FillY(PercentageHeight):
     def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1,keep_autoresize)
+        super().__init__(1, keep_autoresize)
         self.name = "fill_y"
 
 
-class Height(Constraint):
-    def __init__(self, height: float, keep_autoresize: bool = False):
-        if height < 0:
-            raise ValueError("height can't be negative")
-        super().__init__(name="height")
-        self.height = height
+class PercentageRectHeight(Constraint):
+    def __init__(self, percentage: float, keep_autoresize: bool = False):
+        super().__init__(name="percentage_rect_height")
+        self.percentage: float = percentage
         self.keep_autoresize: bool = keep_autoresize
 
-    def __str__(self) -> str:
-        return f"{super().__str__()}.(height={self.height})"
-
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == self.height
+        return child_widget.rect.height == round(
+            parent_widget.rect.height * self.percentage
+        )
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}.[{self.percentage*100}%, keep_autoresize={self.keep_autoresize}]"
 
     def apply_constraint(self, parent_widget, child_widget):
         if child_widget.autoresize_h:
             if self.keep_autoresize:
-                print(f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True")
+                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, self.height))
+        child_widget.set_size(
+            (None, round(parent_widget.rect.height * self.percentage))
+        )
 
 
-class Width(Constraint):
-    def __init__(self, width: float, keep_autoresize: bool = False):
-        if width < 0:
-            raise ValueError("width can't be negative")
-        super().__init__(name="width")
-        self.width = width
+class PercentageRectWidth(Constraint):
+    def __init__(self, percentage: float, keep_autoresize: bool = False):
+        super().__init__(name="percentage_rect_width")
+        self.percentage: float = percentage
         self.keep_autoresize: bool = keep_autoresize
 
-    def __str__(self) -> str:
-        return f"{super().__str__()}.(width={self.width})"
-
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == self.width
+        return child_widget.rect.width == round(
+            parent_widget.rect.width * self.percentage
+        )
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}.[{self.percentage*100}%, keep_autoresize={self.keep_autoresize}]"
 
     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"
+                    f"WARNING: Constraint on {child_widget} can't resize, autoresize set to True"
                 )
                 return
             child_widget.set_autoresize_w(False)
-        child_widget.set_size((self.width, None))
+        child_widget.set_size((round(parent_widget.rect.width * self.percentage), None))
+
+
+class FillRectX(PercentageRectWidth):
+    def __init__(self, keep_autoresize: bool = False):
+        super().__init__(1, keep_autoresize)
+        self.name = "fill_rect_x"
+
+
+class FillRectY(PercentageRectHeight):
+    def __init__(self, keep_autoresize: bool = False):
+        super().__init__(1, keep_autoresize)
+        self.name = "fill_rect_y"
 
 
 class AspectRatio(Constraint):
@@ -205,13 +236,17 @@ class AspectRatio(Constraint):
         keep_autoresize=False,
     ):
         super().__init__(name="aspect_ratio")
-        self.ref_axis : bf.axis = reference_axis
+        self.ref_axis: bf.axis = reference_axis
         self.keep_autoresize: bool = keep_autoresize
 
         if isinstance(ratio, float | int):
             self.ratio = ratio
         elif isinstance(ratio, pygame.rect.FRect):
-            self.ratio = (ratio.w / ratio.h) if reference_axis == bf.axis.HORIZONTAL else (ratio.h / ratio.w)
+            self.ratio = (
+                (ratio.w / ratio.h)
+                if reference_axis == bf.axis.HORIZONTAL
+                else (ratio.h / ratio.w)
+            )
         else:
             raise TypeError(f"Ratio must be float or FRect")
 
@@ -224,17 +259,17 @@ class AspectRatio(Constraint):
     def apply_constraint(self, parent_widget, child_widget):
 
         if self.ref_axis == bf.axis.VERTICAL:
-            if child_widget.autoresize_w :
+            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((child_widget.rect.h * self.ratio,None))
-        
+            child_widget.set_size((child_widget.rect.h * self.ratio, None))
+
         if self.ref_axis == bf.axis.HORIZONTAL:
-            if child_widget.autoresize_h :
+            if child_widget.autoresize_h:
                 if self.keep_autoresize:
                     print(
                         f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
@@ -242,28 +277,39 @@ class AspectRatio(Constraint):
                     return
                 child_widget.set_autoresize_h(False)
             print("HERE")
-            child_widget.set_size((None,child_widget.rect.w * self.ratio))
+            child_widget.set_size((None, child_widget.rect.w * self.ratio))
+
 
 class AnchorBottom(Constraint):
     def __init__(self):
         super().__init__(name="anchor_bottom")
 
     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_bottom() - child_widget.rect.h
+        )
 
     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_bottom() - child_widget.rect.h
+        )
+
 
 class AnchorBottom(Constraint):
     def __init__(self):
         super().__init__(name="anchor_bottom")
 
     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_bottom() - child_widget.rect.h
+        )
 
     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_bottom() - child_widget.rect.h
+        )
 
 
 class AnchorTopRight(Constraint):
@@ -334,10 +380,12 @@ class MarginBottom(Constraint):
         )
 
     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
+        child_widget.set_position(
+            child_widget.rect.x,
+            parent_widget.get_padded_bottom() - child_widget.rect.h - self.margin,
         )
 
+
 class MarginTop(Constraint):
     def __init__(self, margin: float):
         super().__init__(name="margin_top")
@@ -347,7 +395,9 @@ class MarginTop(Constraint):
         return child_widget.rect.top == parent_widget.get_padded_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.set_position(
+            child_widget.rect.x, parent_widget.get_padded_top() + self.margin
+        )
 
 
 class MarginLeft(Constraint):
@@ -360,7 +410,9 @@ class MarginLeft(Constraint):
 
     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)
+            child_widget.set_position(
+                parent_widget.get_padded_left() + self.margin, child_widget.rect.y
+            )
 
 
 class MarginRight(Constraint):
@@ -374,5 +426,165 @@ class MarginRight(Constraint):
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_position(
             parent_widget.get_padded_right() - child_widget.rect.w - self.margin,
-            child_widget.rect.y
+            child_widget.rect.y,
+        )
+
+
+class PercentageMarginBottom(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_margin_bottom")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.bottom
+            == parent_widget.get_padded_top()
+            + parent_widget.get_padded_height() * 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
+            - parent_widget.get_padded_height() * self.margin,
+        )
+
+
+class PercentageMarginTop(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_margin_top")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.top
+            == parent_widget.get_padded_top()
+            + parent_widget.get_padded_height() * self.margin
+        )
+
+    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,
+        )
+
+
+class PercentageMarginLeft(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_margin_left")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.left
+            == parent_widget.get_padded_left()
+            + parent_widget.get_padded_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,
+                child_widget.rect.y,
+            )
+
+
+class PercentageMarginRight(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_margin_right")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.right
+            == parent_widget.get_padded_right()
+            - parent_widget.get_padded_width() * self.margin
+        )
+
+    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_width() * self.margin,
+            child_widget.rect.y,
+        )
+
+
+class PercentageRectMarginBottom(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_rect_margin_bottom")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.bottom
+            == parent_widget.rect.top + parent_widget.rect.height * self.margin
+        )
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            child_widget.rect.x,
+            parent_widget.rect.bottom
+            - child_widget.rect.height
+            - parent_widget.rect.height * self.margin,
+        )
+
+
+class PercentageRectMarginTop(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_rect_margin_top")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.top
+            == parent_widget.rect.top + parent_widget.rect.height * self.margin
+        )
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            child_widget.rect.x,
+            parent_widget.rect.top + parent_widget.rect.height * self.margin,
+        )
+
+
+class PercentageRectMarginLeft(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_rect_margin_left")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.left
+            == parent_widget.rect.left + parent_widget.rect.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.rect.left + parent_widget.rect.width * self.margin,
+                child_widget.rect.y,
+            )
+
+
+class PercentageRectMarginRight(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="percentage_rect_margin_right")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.right
+            == parent_widget.rect.right - parent_widget.rect.width * self.margin
+        )
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.rect.right
+            - child_widget.rect.width
+            - parent_widget.rect.width * self.margin,
+            child_widget.rect.y,
         )

batFramework/gui/container.py

@@ -20,6 +20,9 @@ class Container(Shape, InteractiveWidget):
         self.layout.set_parent(self)
         self.add(*children)
 
+    def __str__(self) -> str:
+        return f"Container({self.uid},{len(self.children)})"
+
     def get_min_required_size(self):
         if self.layout:
             return self.layout.get_auto_size()
@@ -50,6 +53,23 @@ class Container(Shape, InteractiveWidget):
         self.dirty_children = True
         return self
 
+    def clamp_scroll(self) -> Self:
+        if not self.children:
+            return Self
+        r = self.get_padded_rect()
+        size = self.children[0].rect.unionall(self.children[1:]).size
+
+        # Calculate the maximum scroll values
+        max_scroll_x = max(0, size[0] - r.width)
+        max_scroll_y = max(0, size[1] - r.height)
+
+        # Clamp the scroll values
+        self.scroll.x = max(0, min(self.scroll.x, max_scroll_x))
+        self.scroll.y = max(0, min(self.scroll.y, max_scroll_y))
+
+        self.dirty_children = True
+        return self
+
     def set_layout(self, layout: Layout) -> Self:
         tmp = self.layout
         self.layout = layout
@@ -57,23 +77,16 @@ class Container(Shape, InteractiveWidget):
             self.dirty_children = True
         return self
 
-
-    def get_debug_outlines(self):
-        yield (self.rect, self.debug_color)
-        yield (self.get_padded_rect(), self.debug_color)
-
-        for child in self.children:
-            yield from child.get_debug_outlines()
-            # for data in child.get_debug_outlines():
-
     def get_interactive_children(self) -> list[InteractiveWidget]:
         return [
-            child for child in self.children if isinstance(child, InteractiveWidget) and child.allow_focus_to_self()
+            child
+            for child in self.children
+            if isinstance(child, InteractiveWidget) and child.allow_focus_to_self()
         ]
 
     def focus_next_child(self) -> None:
         self.layout.focus_next_child()
-        
+
     def focus_prev_child(self) -> None:
         self.layout.focus_prev_child()
 
@@ -94,14 +107,11 @@ class Container(Shape, InteractiveWidget):
     def resolve_constraints(self) -> None:
         super().resolve_constraints()
 
-    def __str__(self) -> str:
-        return f"Container({self.uid},{len(self.children)})"
-
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
         if self.visible and self.rect.collidepoint(x, y):
             if self.children:
                 for child in reversed(self.children):
-                    r = child.top_at(x,y)
+                    r = child.top_at(x, y)
                     if r is not None:
                         return r
             return self
@@ -117,16 +127,22 @@ class Container(Shape, InteractiveWidget):
         self.focused_index = min(self.focused_index, len(l))
         return l[self.focused_index].get_focus()
 
+    def do_handle_event(self, event):
+        self.layout.handle_event(event)
+
     def set_focused_child(self, child: InteractiveWidget) -> bool:
         l = self.get_interactive_children()
-        i = l.index(child)
+        try:
+            i = l.index(child)
+        except ValueError:
+            return False
         if i >= 0:
             self.focused_index = i
             return True
         return False
 
     def allow_focus_to_self(self) -> bool:
-        return len(self.get_interactive_children()) != 0
+        return len(self.get_interactive_children()) != 0 and self.visible
 
     def draw(self, camera: bf.Camera) -> None:
         constraints_down = False
@@ -144,7 +160,8 @@ class Container(Shape, InteractiveWidget):
                 self.parent.visit_up(self.selective_up)
             else:
                 constraints_down = True
-
+        if not self.dirty_children:
+            self.dirty_children = any(c.dirty_shape for c in self.children)
         if self.dirty_children:
             if self.layout:
                 self.layout.arrange()
@@ -157,7 +174,6 @@ class Container(Shape, InteractiveWidget):
             self.paint()
             self.dirty_surface = False
 
-
         bf.Entity.draw(self, camera)
 
         if self.clip_children:
@@ -166,8 +182,10 @@ class Container(Shape, InteractiveWidget):
             new_clip = new_clip.clip(old_clip)
             camera.surface.set_clip(new_clip)
         # Draw children with adjusted positions
-        _ = [child.draw(camera) for child in sorted(self.children, key=lambda c: c.render_order)]
+        _ = [
+            child.draw(camera)
+            for child in sorted(self.children, key=lambda c: c.render_order)
+        ]
 
         if self.clip_children:
             camera.surface.set_clip(old_clip)
-

batFramework/gui/debugger.py

@@ -7,6 +7,7 @@ import pygame
 def convert_to_int(*args):
     return [int(arg) for arg in args]
 
+
 class Debugger(Label):
     def __init__(self) -> None:
         super().__init__("")
@@ -17,12 +18,6 @@ class Debugger(Label):
         self.add_tags("debugger")
         self.set_visible(False)
 
-    # def get_debug_outlines(self):
-    #     yield None
-
-    def to_string_id(self) -> str:
-        return "Debugger"
-
     def set_refresh_rate(self, value: int) -> Self:
         self.refresh_rate = value
         return self
@@ -61,14 +56,17 @@ class Debugger(Label):
     def update_text(self) -> None:
         if not self.parent_scene:
             return
+
         d = "\n".join(
             key + ":" + data if key != "" else data
             for key, data in self.static_data.items()
         )
+
         d2 = "\n".join(
             key + ":" + str(data()) if key != "" else str(data())
             for key, data in self.dynamic_data.items()
         )
+
         self.set_text("\n".join((d, d2)).strip())
 
     def update(self, dt: float) -> None:
@@ -83,13 +81,17 @@ class Debugger(Label):
             self.refresh_counter = 0
             self.update_text()
 
-
-    def __str__(self)->str:
+    def __str__(self) -> str:
         return "Debugger"
-    # def top_at(self,x,y):
-        # return None
+
+    def top_at(self, x, y):
+        return None
+
 
 class FPSDebugger(Debugger):
+    def __init__(self):
+        super().__init__()
+
     def do_when_added(self):
         if not self.parent_scene or not self.parent_scene.manager:
             print("Debugger could not link to the manager")
@@ -125,4 +127,9 @@ class BasicDebugger(FPSDebugger):
         self.add_dynamic("W. Ent.", lambda: parent_scene.get_world_entity_count())
         self.add_dynamic("H. Ent.", lambda: parent_scene.get_hud_entity_count())
 
-        self.add_dynamic("Hover",lambda : str(parent_scene.root.hovered) if parent_scene.root.hovered else None)
+        self.add_dynamic(
+            "Hover",
+            lambda: (
+                str(parent_scene.root.hovered) if parent_scene.root.hovered else None
+            ),
+        )