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

batFramework/gui/container.py

@@ -4,7 +4,6 @@ from .shape import Shape
 from .interactiveWidget import InteractiveWidget
 from .layout import Layout, Column
 from typing import Self
-import pygame
 from pygame.math import Vector2
 
 
@@ -66,15 +65,21 @@ class Container(Shape, InteractiveWidget):
     def clamp_scroll(self) -> Self:
         if not self.children:
             return self
-        r = self.get_padded_rect()
-        size = self.children[0].rect.unionall([child.rect for child in self.children[1:]]).size
-
-        max_scroll_x = max(0, size[0] - r.width)
-        max_scroll_y = max(0, size[1] - r.height)
-
-        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_layout = True
+        r = self.get_inner_rect()
+        # Compute the bounding rect of all children in one go
+        children_rect = self.children[0].rect.copy()
+        for child in self.children[1:]:
+            children_rect.union_ip(child.rect)
+        max_scroll_x = max(0, children_rect.width - r.width)
+        max_scroll_y = max(0, children_rect.height - r.height)
+
+        # Clamp scroll values only if needed
+        new_x = min(max(self.scroll.x, 0), max_scroll_x)
+        new_y = min(max(self.scroll.y, 0), max_scroll_y)
+
+        if self.scroll.x != new_x or self.scroll.y != new_y:
+            self.scroll.x = new_x
+            self.scroll.y = new_y
         return self
 
     def set_layout(self, layout: Layout) -> Self:
@@ -83,6 +88,7 @@ class Container(Shape, InteractiveWidget):
         if self.layout != tmp:
             tmp.set_parent(None)
             self.layout.set_parent(self)
+            self.reset_scroll()
             self.dirty_layout = True
         return self
 
@@ -96,13 +102,13 @@ class Container(Shape, InteractiveWidget):
     def add(self, *child: Widget) -> Self:
         super().add(*child)
         self.dirty_shape = True
-        self.clamp_scroll()
+        self.dirty_layout = True
         return self
 
     def remove(self, *child: Widget) -> Self:
         super().remove(*child)
         self.dirty_shape = True
-        self.clamp_scroll()
+        self.dirty_layout = True
         return self
 
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
@@ -123,60 +129,78 @@ class Container(Shape, InteractiveWidget):
         self.focused_index = min(self.focused_index, len(interactive_children) - 1)
         return interactive_children[self.focused_index].get_focus()
 
+    def children_has_focus(self)->bool:
+        return any(child.is_focused for child in self.get_interactive_children())
+
     def do_handle_event(self, event) -> None:
-        if any(child.is_focused for child in self.get_interactive_children()):
-            self.layout.handle_event(event)
+        if event.consumed:
+            return
+        self.layout.handle_event(event)
 
     def set_focused_child(self, child: InteractiveWidget) -> bool:
         interactive_children = self.get_interactive_children()
         try:
             index = interactive_children.index(child)
             self.focused_index = index
+            if self.layout : 
+                self.layout.scroll_to_widget(child)
             return True
         except ValueError:
             return False
 
     def allow_focus_to_self(self) -> bool:
         return bool(self.get_interactive_children()) and self.visible
+    
+    def build(self) -> None:
+        if self.layout is not None:
+            # print("I'm building !",self)
+            # size = self.expand_rect_with_padding((0,0,*self.layout.get_auto_size())).size
+            size = self.layout.get_auto_size()
+            self.set_size(self.resolve_size(size))
+        super().build()
+
+    def apply_pre_updates(self):
+        if self.dirty_size_constraints or self.dirty_shape:
+            self.resolve_constraints(size_only=True)
+            self.dirty_size_constraints = False
+            self.dirty_position_constraints = True
 
+        if self.dirty_layout:
+            self.layout.update_child_constraints()
+            self.layout.arrange()
+            self.dirty_layout = 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
+    def apply_post_updates(self,skip_draw:bool=False):
+        """
+        BOTTOM TO TOP
+        for cases when widget attributes depend on children attributes
+        """
         if self.dirty_shape:
-            self.build()  # Finalize size of the container
+            self.layout.update_child_constraints()
+            self.build()
             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_surface = True
+            self.dirty_layout =  True
+            self.dirty_size_constraints = True
+            self.dirty_position_constraints = True
+            from .container import Container
+            if self.parent and isinstance(self.parent, Container):
+                self.parent.dirty_layout = True
+                self.parent.dirty_shape = True
 
-        for child in self.children:
-            child.apply_updates()
+            # trigger layout or constraint updates in parent
+            
 
-        # 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:
-            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 !!")
+            # force recheck of constraints
+
+
+        if self.dirty_position_constraints:
+            self.resolve_constraints(position_only=True)
+            self.dirty_position_constraints= False
+
+
+        if self.dirty_surface and not skip_draw:
             self.paint()
             self.dirty_surface = False
+  
+

batFramework/gui/debugger.py

@@ -2,6 +2,7 @@ from .label import Label
 from typing import Self,Callable,Any
 import batFramework as bf
 import pygame
+import sys
 
 
 def convert_to_int(*args):
@@ -46,7 +47,7 @@ class Debugger(Label):
 
     def set_parent_scene(self, scene) -> Self:
         super().set_parent_scene(scene)
-        self.set_render_order(99)
+        self.set_render_order(sys.maxsize-100)
         self.update_text()
         return self
 
@@ -72,15 +73,19 @@ class Debugger(Label):
     def update(self, dt: float) -> None:
         if not self.parent_scene:
             return
+        
         if bf.ResourceManager().get_sharedVar("debug_mode") != bf.debugMode.DEBUGGER:
             self.set_visible(False)
             return
+        
         self.set_visible(True)
         self.refresh_counter = self.refresh_counter + (dt * 60)
+        
         if self.refresh_counter > self.refresh_rate:
             self.refresh_counter = 0
             self.update_text()
 
+
     def __str__(self) -> str:
         return "Debugger"
 
@@ -109,23 +114,13 @@ class BasicDebugger(FPSDebugger):
             "Resolution", lambda: "x".join(str(i) for i in bf.const.RESOLUTION)
         )
         super().do_when_added()
-        parent_scene = self.parent_scene
-
         self.add_dynamic("Mouse", pygame.mouse.get_pos)
-        self.add_dynamic(
-            "World",
-            lambda: convert_to_int(
-                *parent_scene.camera.screen_to_world(pygame.mouse.get_pos())
-            ),
-        )
-        self.add_dynamic(
-            "Hud",
-            lambda: convert_to_int(
-                *parent_scene.hud_camera.screen_to_world(pygame.mouse.get_pos())
-            ),
-        )
-        self.add_dynamic("W. Ent.", lambda: parent_scene.get_world_entity_count())
-        self.add_dynamic("H. Ent.", lambda: parent_scene.get_hud_entity_count())
+
+        if not hasattr(self.parent_scene,"root"):
+            print("Debugger couldn't find 'root' widget in parent scene")
+            return
+        
+        parent_scene = self.parent_scene
 
         self.add_dynamic(
             "Hover",

batFramework/gui/draggableWidget.py

@@ -5,34 +5,31 @@ import pygame
 
 class DraggableWidget(InteractiveWidget):
     def __init__(self, *args, **kwargs) -> None:
-        self.drag_action = bf.Action("dragging").add_mouse_control(1).set_holding()
 
         self.drag_start = None
         self.offset = None
         super().__init__(*args, **kwargs)
 
-    def do_process_actions(self, event: pygame.Event) -> None:
-        self.drag_action.process_event(event)
-
-    def do_reset_actions(self) -> None:
-        self.drag_action.reset()
-
+    def on_click_down(self, button):
+        if super().on_click_down(button)==False:
+            return button == 1 # capture event
+    
     def do_on_drag(
         self, drag_start: tuple[float, float], drag_end: tuple[float, float]
     ) -> None:
         self.set_position(drag_end[0] - self.offset[0], drag_end[1] - self.offset[1])
 
+
     def update(self, dt: float):
-        if self.drag_action.active and self.is_clicked_down:
+        if self.is_clicked_down and pygame.mouse.get_pressed(3)[0]:
             r = self.get_root()
             x, y = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
-            if self.drag_start == None and self.drag_action.active:
+            if self.drag_start == None and self.is_clicked_down:
                 self.offset = x - self.rect.x, y - self.rect.y
                 self.drag_start = x, y
-                return
             else:
                 self.do_on_drag(self.drag_start, (x, y))
-                return
+                
         else:
             self.drag_start = None
             self.offset = None

batFramework/gui/image.py

@@ -23,7 +23,7 @@ class Image(Shape):
         super().paint()
         if self.original_surface is None:
             return
-        padded = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
+        padded = self.get_inner_rect().move(-self.rect.x,-self.rect.y)
         target_size = padded.size
         if self.original_surface.get_size() != target_size:
             self.surface.blit(pygame.transform.scale(self.original_surface, target_size), padded.topleft)
@@ -32,17 +32,11 @@ class Image(Shape):
 
     def build(self) -> None:
         if self.original_surface is not None:
-            self.set_size_if_autoresize(
-                self.inflate_rect_by_padding((0,0,*self.original_surface.get_size())).size
+            self.set_size(
+                self.expand_rect_with_padding((0,0,*self.original_surface.get_size())).size
             )
         super().build()
 
-    def get_min_required_size(self) -> tuple[float, float]:
-        res = self.rect.size
-        return self.inflate_rect_by_padding((0, 0, *res)).size
-
-
-
 
     def from_path(self, path: str) -> Self:
         tmp = bf.ResourceManager().get_image(path, self.convert_alpha)
@@ -60,6 +54,5 @@ class Image(Shape):
         self.original_surface = surface
         size = self.original_surface.get_size()
         self.set_size(size)
-
         self.dirty_surface = True
         return self

batFramework/gui/indicator.py

@@ -8,6 +8,12 @@ import batFramework as bf
 
 
 class Indicator(Shape):
+    """
+    Shape intended to be used as icons/indicators
+    due to its nature, it overrides the top_at function (it can not be 'seen' by the mouse)
+    
+    """
+    
     def __init__(self, size: tuple[int | float] = (10, 10)) -> None:
         super().__init__(size)
         self.debug_color = "magenta"
@@ -35,7 +41,7 @@ class ToggleIndicator(Indicator):
         self.set_value(default_value)
         self.callback(default_value)
         # TODO aspect ratio would be good right about here
-        # self.add_constraint(ConstraintAspectRatio(1))
+        self.add_constraints(bf.gui.AspectRatio(1,reference_axis=bf.axis.VERTICAL))
 
     def set_callback(self, callback : Callable[[bool],Any]) -> Self:
         self.callback = callback
@@ -56,3 +62,69 @@ class ToggleIndicator(Indicator):
             return None
         return r
 
+class ArrowIndicator(Indicator):
+    def __init__(self,direction:bf.direction):
+        super().__init__()
+        self.direction : bf.direction = direction
+        self.arrow_color = bf.color.WHITE
+        self.line_width : int = 1
+        self.angle : float  = 45
+        self.spread : float = None 
+        self.draw_stem : bool = True
+        
+    def set_draw_stem(self,value:bool)->Self:
+        self.draw_stem = value
+        self.dirty_surface = False
+        return self
+
+    def set_spread(self,value:float)->Self:
+        self.spread = value
+        self.dirty_surface = True
+        return self
+
+    def set_angle(self,value:float)->Self:
+        self.angle = value
+        self.dirty_surface = True
+        return self
+        
+    def set_arrow_color(self,color)-> Self:
+        self.arrow_color = color
+        self.dirty_surface = True
+        return self
+
+    def set_direction(self,direction:bf.direction)->Self:
+        self.direction = direction
+        self.dirty_surface = True
+        return self
+
+    def set_line_width(self,value:int)->Self:
+        self.line_width = value
+        self.dirty_surface = True
+        return self
+        
+    def paint(self):
+        super().paint()
+        r = self.get_local_padded_rect()
+        size = min(r.width, r.height)
+        if size %2 == 0:
+            size -= 1
+        r.width = size
+        r.height = size
+        if (self.padding[1]+self.padding[3] )%2 ==0:
+            r.height-=1
+        if (self.padding[0]+self.padding[2] )%2 ==0:
+            r.width-=1
+        r.center = self.get_local_padded_rect().center
+        # r.inflate_ip(3,3)
+        # r.normalize()
+        # r.move_ip(-self.rect.left,-self.rect.right)
+        bf.utils.draw_triangle(
+            surface = self.surface,
+            color = self.arrow_color,
+            rect =r,
+            direction = self.direction,
+
+        )
+        
+
+

batFramework/gui/interactiveWidget.py

@@ -56,7 +56,7 @@ class InteractiveWidget(Widget):
 
     def on_get_focus(self) -> None:
         self.is_focused = True
-        if isinstance(self.parent,bf.Container):
+        if isinstance(self.parent,bf.gui.Container):
             self.parent.layout.scroll_to_widget(self) 
         self.do_on_get_focus()
 
@@ -64,97 +64,131 @@ class InteractiveWidget(Widget):
         self.is_focused = False
         self.do_on_lose_focus()
 
-    def focus_next_tab(self, previous_widget):
-
-        if previous_widget != self and self.visible:
-            if (
-                isinstance(self, InteractiveWidget)
-                and not isinstance(self, bf.Container)
-                and self.allow_focus_to_self()
-            ):
-                self.focus_next_sibling()
-                return
-            i_children = [
-                c
-                for c in self.children
-                if isinstance(c, InteractiveWidget) and c.visible
-            ]
-            if i_children:
-                index = i_children.index(previous_widget)
-                if index < len(i_children) - 1:
-
-                    i_children[index + 1].get_focus()
-                    return
-
-        if self.parent and isinstance(self.parent,InteractiveWidget):
-            self.parent.focus_next_tab(self)
+        
 
-    def focus_prev_tab(self, previous_widget):
-        if previous_widget != self and self.visible:
-            if (
-                isinstance(self, InteractiveWidget)
-                and not isinstance(self, bf.Container)
-                and self.allow_focus_to_self()
-            ):
-                self.get_focus()
-                return
-            i_children = [
-                c
-                for c in self.children
-                if isinstance(c, InteractiveWidget) and c.visible
-            ]
-
-            if i_children:
-                index = i_children.index(previous_widget)
-                if index > 0:
-                    i_children[index - 1].get_focus()
-                    return
-
-        if self.parent and isinstance(self.parent,InteractiveWidget):
-            self.parent.focus_prev_tab(self)
+    def get_interactive_widgets(self):
+        """Retrieve all interactive widgets in the tree, in depth-first order."""
+        widgets = []
+        stack = [self]
+        while stack:
+            widget = stack.pop()
+            if isinstance(widget, InteractiveWidget) and widget.allow_focus_to_self():
+                widgets.append(widget)
+            stack.extend(reversed(widget.children))  # Add children in reverse for left-to-right traversal
+        return widgets
+
+    def find_next_widget(self, current):
+        """Find the next interactive widget, considering parent and sibling relationships."""
+        if current.is_root:
+            return None  # Root has no parent
+
+        siblings = current.parent.children
+        start_index = siblings.index(current)
+        good_index = -1
+        for i in range(start_index + 1, len(siblings)):
+            if isinstance(siblings[i], InteractiveWidget) and siblings[i].allow_focus_to_self():
+                good_index = i
+                break
+        if good_index >= 0:
+            # Not the last child, return the next sibling
+            return siblings[good_index]
+        else:
+            # Current is the last child, move to parent's next sibling
+            return self.find_next_widget(current.parent)
+
+    def find_prev_widget(self, current : "Widget"):
+        """Find the previous interactive widget, considering parent and sibling relationships."""
+        if current.is_root:
+            return None  # Root has no parent
+
+        # siblings = [c for c in current.parent.children if isinstance(c,InteractiveWidget) and c.allow_focus_to_self()]
+        siblings = current.parent.children
+        start_index = siblings.index(current)
+        good_index = -1
+        for i in range(start_index-1,-1,-1):
+            sibling = siblings[i]
+            if isinstance(sibling,InteractiveWidget):
+                if sibling.allow_focus_to_self():
+                    good_index = i
+                    break
+        if good_index >= 0:
+            # Not the first child, return the previous sibling
+            return siblings[good_index]
+        else:
+            # Current is the first child, move to parent's previous sibling
+            return self.find_prev_widget(current.parent)
 
-    def on_key_down(self, key) -> bool:
-        if key == pygame.K_TAB and self.parent:
-            keys = pygame.key.get_pressed()
-            if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
+    def focus_next_tab(self, previous_widget):
+        """Focus the next interactive widget."""
+        if previous_widget:
+            next_widget = self.find_next_widget(previous_widget)
+            if next_widget:
+                next_widget.get_focus()
 
-                self.focus_prev_tab(self)
-            else:
-                self.focus_next_tab(self)
-            return True
-        else:
+    def focus_prev_tab(self, previous_widget):
+        """Focus the previous interactive widget."""
+        if previous_widget:
+            prev_widget = self.find_prev_widget(previous_widget)
+            if prev_widget:
+                prev_widget.get_focus()
 
-            return self.do_on_key_down(key)
 
-        return False
+    
+    def on_key_down(self, key) -> bool:
+        """
+        return True to stop event progpagation
+        """
+        return self.do_on_key_down(key)
 
     def on_key_up(self, key) -> bool:
+        """
+        return True to stop event progpagation
+        """
         return self.do_on_key_up(key)
 
+    def do_on_get_focus(self) -> None:
+        pass
+
+    def do_on_lose_focus(self) -> None:
+        pass
+
     def do_on_key_down(self, key) -> bool:
+        """
+        return True to stop event progpagation
+        """
         return False
 
     def do_on_key_up(self, key) -> bool:
+        """
+        return True to stop event progpagation
+        """
         return False
 
-    def do_on_get_focus(self) -> None:
-        pass
-
-    def do_on_lose_focus(self) -> None:
-        pass
 
     def on_click_down(self, button: int) -> bool:
+        """
+        return True to stop event progpagation
+        """
         self.is_clicked_down = True
         return self.do_on_click_down(button)
 
     def on_click_up(self, button: int) -> bool:
+        """
+        return True to stop event progpagation
+        """
         self.is_clicked_down = False
         return self.do_on_click_up(button)
 
     def do_on_click_down(self, button: int) -> bool:
+        """
+        return True to stop event progpagation
+        """
         return False
 
     def do_on_click_up(self, button: int) -> bool:
+        """
+        return True to stop event progpagation
+        """
         return False
 
     def on_enter(self) -> None:
@@ -182,39 +216,22 @@ class InteractiveWidget(Widget):
         pass
 
     def draw_focused(self, camera: bf.Camera) -> None:
-
-        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),
-        )
+        prop = 16
+        pulse = int(prop * 0.75 - (prop * cos(pygame.time.get_ticks() / 100) / 4))
+        delta = (pulse // 2) * 2  # ensure even
+
+        # Get rect in screen space, inflated for visual effect
+        screen_rect = camera.world_to_screen(self.rect.inflate(prop, prop))
+
+        # Shrink for inner pulsing border
+        inner = screen_rect.inflate(-delta, -delta)
+        inner.topleft = 0,0
+        surface = pygame.Surface(inner.size)
+        surface.set_colorkey((0,0,0))
+        pygame.draw.rect(surface, "white", inner, 2, *self.border_radius)
+        pygame.draw.rect(surface, "black", inner.inflate(-16,0), 2)
+        pygame.draw.rect(surface, "black", inner.inflate(0,-16), 2)
+        inner.center = screen_rect.center
+        camera.surface.blit(surface,inner)
+
+        # pygame.draw.rect(camera.surface, "white", inner, 2, *self.border_radius)