batframework 1.0.8a13__py3-none-any.whl → 1.0.9a1__py3-none-any.whl

batFramework/gui/constraints/constraints.py

@@ -598,6 +598,95 @@ class MarginRight(Constraint):
             other.margin == self.margin
         )
 
+class RectMarginBottom(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.bottom == parent_widget.rect.bottom - 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.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 RectMarginTop(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.top == parent_widget.rect.top + self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            child_widget.rect.x, parent_widget.rect.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 RectMarginLeft(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.left == parent_widget.rect.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.rect.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 RectMarginRight(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.right == parent_widget.rect.right - self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.rect.right - child_widget.rect.w - 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 PercentageMarginBottom(Constraint):
     def __init__(self, margin: float):
         super().__init__()
@@ -812,4 +901,4 @@ class PercentageRectMarginRight(Constraint):
         return (
             other.name == self.name and
             other.margin == self.margin
-        )
+        )

batFramework/gui/container.py

@@ -11,181 +11,172 @@ from pygame.math import Vector2
 class Container(Shape, InteractiveWidget):
     def __init__(self, layout: Layout = None, *children: Widget) -> None:
         super().__init__()
-        self.dirty_children = False
+        self.dirty_layout: bool = False
         self.set_debug_color("green")
-        self.layout: Layout = layout
-        self.scroll = Vector2(0, 0)
-        if not self.layout:
-            self.layout = Column()
+        self.layout = layout if layout else Column()
         self.layout.set_parent(self)
+        self.scroll = Vector2(0, 0)
         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()
-        return self.rect.size
+        return self.layout.get_auto_size() if self.layout else self.rect.size
 
     def reset_scroll(self) -> Self:
+        if self.scroll == (0,0):
+            return self
         self.scroll.update(0, 0)
-        self.dirty_children = True
+        self.dirty_layout = True
         return self
 
     def set_scroll(self, value: tuple) -> Self:
+        if (self.scroll.x,self.scroll.y) == value:
+            return self
         self.scroll.update(value)
-        self.dirty_children = True
+        self.clamp_scroll()
+        self.dirty_layout = True
         return self
 
     def scrollX_by(self, x: float | int) -> Self:
+        if x == 0:
+            return self
         self.scroll.x += x
-        self.dirty_children = True
+        self.clamp_scroll()
+        self.dirty_layout = True
         return self
 
     def scrollY_by(self, y: float | int) -> Self:
+        if y == 0:
+            return self
         self.scroll.y += y
-        self.dirty_children = True
+        self.clamp_scroll()
+        self.dirty_layout = True
         return self
 
     def scroll_by(self, value: tuple[float | int, float | int]) -> Self:
+        if value[0] == 0 and value[1] == 0:
+            return self
         self.scroll += value
-        self.dirty_children = True
+        self.clamp_scroll()
+        self.dirty_layout = True
         return self
 
     def clamp_scroll(self) -> Self:
         if not self.children:
-            return Self
+            return self
         r = self.get_padded_rect()
-        size = self.children[0].rect.unionall(self.children[1:]).size
+        size = self.children[0].rect.unionall([child.rect for child in 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
+        self.dirty_layout = True
         return self
 
     def set_layout(self, layout: Layout) -> Self:
         tmp = self.layout
         self.layout = layout
         if self.layout != tmp:
-            self.dirty_children = True
+            tmp.set_parent(None)
+            self.layout.set_parent(self)
+            self.dirty_layout = True
         return self
 
     def get_interactive_children(self) -> list[InteractiveWidget]:
-        return [
-            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()
+        return [child for child in self.children if isinstance(child, InteractiveWidget) and not isinstance(child,Container) and child.allow_focus_to_self()]
 
     def clear_children(self) -> None:
         self.children.clear()
-        self.dirty_children = True
+        self.dirty_layout = True
 
     def add(self, *child: Widget) -> Self:
         super().add(*child)
-        self.dirty_children = True
+        self.dirty_shape = True
+        self.clamp_scroll()
         return self
 
     def remove(self, *child: Widget) -> Self:
         super().remove(*child)
-        self.dirty_children = True
+        self.dirty_shape = True
+        self.clamp_scroll()
         return self
 
-    def resolve_constraints(self) -> None:
-        super().resolve_constraints()
-
     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)
-                    if r is not None:
-                        return r
+            for child in reversed(self.children):
+                result = child.top_at(x, y)
+                if result is not None:
+                    return result
             return self
         return None
 
     def get_focus(self) -> bool:
-        res = super().get_focus()
-        if not res:
+        if not super().get_focus():
             return False
-        l = l = self.get_interactive_children()
-        if not l:
+        interactive_children = self.get_interactive_children()
+        if not interactive_children:
             return True
-        self.focused_index = min(self.focused_index, len(l))
-        return l[self.focused_index].get_focus()
+        self.focused_index = min(self.focused_index, len(interactive_children) - 1)
+        return interactive_children[self.focused_index].get_focus()
 
-    def do_handle_event(self, event):
-        self.layout.handle_event(event)
+    def do_handle_event(self, event) -> None:
+        if any(child.is_focused for child in self.get_interactive_children()):
+            self.layout.handle_event(event)
 
     def set_focused_child(self, child: InteractiveWidget) -> bool:
-        l = self.get_interactive_children()
+        interactive_children = self.get_interactive_children()
         try:
-            i = l.index(child)
+            index = interactive_children.index(child)
+            self.focused_index = index
+            return True
         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 and self.visible
+        return bool(self.get_interactive_children()) and self.visible
 
-    def draw(self, camera: bf.Camera) -> None:
-        constraints_down = False
+
+    def apply_updates(self):
+        if any(child.dirty_shape for child in self.children):
+            self.dirty_layout = True  # Mark layout as dirty if any child changed size
+
+        if self.dirty_constraints:
+            self.resolve_constraints()  # Finalize positioning based on size
+    
+        # Step 1: Build shape if needed
         if self.dirty_shape:
-            self.dirty_constraints = True
-            self.dirty_children = True
-            self.dirty_surface = True
-            self.build()
+            self.build()  # Finalize size of the container
+            self.dirty_shape = False
+            self.dirty_surface = True  # Mark surface for repaint
+            self.dirty_layout = True  # Mark layout for arrangement
+            # Flag all children to update constraints after size is finalized
             for child in self.children:
                 child.dirty_constraints = True
-            self.dirty_shape = False
 
+        for child in self.children:
+            child.apply_updates()
+
+        # Step 2: Arrange layout if marked as dirty
+        if self.dirty_layout:
+            self.layout.arrange()
+            self.dirty_surface = True
+            self.dirty_layout = False
+            # Constraints may need to adjust based on the layout change
+            self.dirty_constraints = True
+
+        # Step 3: Resolve constraints now that size and layout are finalized
         if self.dirty_constraints:
-            if self.parent and self.parent.dirty_constraints:
-                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()
-            self.dirty_children = False
-
-        if constraints_down:
-            self.visit(lambda c: c.resolve_constraints())
+            self.resolve_constraints()  # Finalize positioning based on size
+            for child in self.children:
+                child.dirty_constraints = True  # Children inherit updated positioning
+            self.dirty_constraints = False
 
+        # Step 4: Paint the surface if marked as dirty
         if self.dirty_surface:
+            # print("PAINT !!")
             self.paint()
             self.dirty_surface = False
-
-        bf.Entity.draw(self, camera)
-
-        if self.clip_children:
-            new_clip = camera.world_to_screen(self.get_padded_rect())
-            old_clip = camera.surface.get_clip()
-            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)
-        ]
-
-        if self.clip_children:
-            camera.surface.set_clip(old_clip)

batFramework/gui/debugger.py

@@ -72,7 +72,7 @@ class Debugger(Label):
     def update(self, dt: float) -> None:
         if not self.parent_scene:
             return
-        if self.parent_scene.get_sharedVar("debug_mode") != bf.debugMode.DEBUGGER:
+        if bf.ResourceManager().get_sharedVar("debug_mode") != bf.debugMode.DEBUGGER:
             self.set_visible(False)
             return
         self.set_visible(True)

batFramework/gui/indicator.py

@@ -29,11 +29,11 @@ class Indicator(Shape):
 
 class ToggleIndicator(Indicator):
     def __init__(self, default_value: bool) -> None:
+        super().__init__((20, 20))
         self.value: bool = default_value
         self.callback = lambda val: self.set_color("green" if val else "red")
-        super().__init__((20, 20))
         self.set_value(default_value)
-
+        self.callback(default_value)
         # TODO aspect ratio would be good right about here
         # self.add_constraint(ConstraintAspectRatio(1))
 
@@ -55,3 +55,4 @@ class ToggleIndicator(Indicator):
         if r is self:
             return None
         return r
+

batFramework/gui/interactiveWidget.py

@@ -2,13 +2,13 @@ from .widget import Widget
 from typing import Self
 from typing import TYPE_CHECKING
 import pygame
-from math import cos
+from math import cos,floor,ceil
 
 if TYPE_CHECKING:
     from .container import Container
 import batFramework as bf
 
-def children_has_focus(widget):
+def children_has_focus(widget)->bool:
     if isinstance(widget,InteractiveWidget) and widget.is_focused:
         return True
     for child in widget.children:
@@ -56,6 +56,8 @@ class InteractiveWidget(Widget):
 
     def on_get_focus(self) -> None:
         self.is_focused = True
+        if isinstance(self.parent,bf.Container):
+            self.parent.layout.scroll_to_widget(self) 
         self.do_on_get_focus()
 
     def on_lose_focus(self) -> None:
@@ -84,7 +86,7 @@ class InteractiveWidget(Widget):
                     i_children[index + 1].get_focus()
                     return
 
-        if self.parent:
+        if self.parent and isinstance(self.parent,InteractiveWidget):
             self.parent.focus_next_tab(self)
 
     def focus_prev_tab(self, previous_widget):
@@ -108,30 +110,18 @@ class InteractiveWidget(Widget):
                     i_children[index - 1].get_focus()
                     return
 
-        if self.parent:
+        if self.parent and isinstance(self.parent,InteractiveWidget):
             self.parent.focus_prev_tab(self)
 
-    def focus_next_sibling(self) -> None:
-        if isinstance(self.parent, bf.Container):
-            self.parent.focus_next_child()
-
-    def focus_prev_sibling(self) -> None:
-        if isinstance(self.parent, bf.Container):
-            self.parent.focus_prev_child()
-
     def on_key_down(self, key) -> bool:
-        if key == pygame.K_DOWN:
-            self.focus_next_sibling()
-        elif key == pygame.K_UP:
-            self.focus_prev_sibling()
-        elif key == pygame.K_TAB and self.parent:
+        if key == pygame.K_TAB and self.parent:
             keys = pygame.key.get_pressed()
             if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
 
                 self.focus_prev_tab(self)
             else:
                 self.focus_next_tab(self)
-
+            return True
         else:
 
             return self.do_on_key_down(key)
@@ -192,10 +182,39 @@ class InteractiveWidget(Widget):
         pass
 
     def draw_focused(self, camera: bf.Camera) -> None:
-        delta = 4 + ((2 * cos(pygame.time.get_ticks() / 100)) // 2) * 2
-        pygame.draw.rect(
-            camera.surface,
-            "white",
-            self.rect.move(-camera.rect.x, -camera.rect.y),#.inflate(delta, delta),
-            1,
+
+        proportion = 16
+        surface = pygame.Surface(self.rect.inflate(proportion,proportion).size)
+        surface.fill("black")
+
+        delta = proportion*0.75 - int(proportion * cos(pygame.time.get_ticks() / 100) /4)
+        delta = delta//2 * 2
+        # Base rect centered in tmp surface
+        base_rect = surface.get_frect()
+        
+        # Expanded white rectangle for border effect
+        white_rect = base_rect.inflate(-delta,-delta)
+        white_rect.center = base_rect.center
+        pygame.draw.rect(surface, "white", white_rect, 2, *self.border_radius)
+        
+        # Black cutout rectangles to create the effect around the edges
+        black_rect_1 = white_rect.copy()
+        black_rect_1.w -= proportion
+        black_rect_1.centerx = white_rect.centerx
+        
+        black_rect_2 = white_rect.copy()
+        black_rect_2.h -= proportion
+        black_rect_2.centery = white_rect.centery
+        
+        surface.fill("black", black_rect_1)
+        surface.fill("black", black_rect_2)
+
+        base_rect.center = self.rect.center
+
+        surface.set_colorkey("black")
+    
+        # Blit the tmp surface onto the camera surface with adjusted position
+        camera.surface.blit(
+            surface,
+            base_rect.move(-camera.rect.x, -camera.rect.y),
         )