batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__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
 
 
@@ -42,39 +41,37 @@ class Container(Shape, InteractiveWidget):
     def scrollX_by(self, x: float | int) -> Self:
         if x == 0:
             return self
-        self.scroll.x += x
-        self.clamp_scroll()
-        self.dirty_layout = True
+        self.set_scroll((self.scroll.x + x, self.scroll.y))
         return self
 
     def scrollY_by(self, y: float | int) -> Self:
         if y == 0:
             return self
-        self.scroll.y += y
-        self.clamp_scroll()
-        self.dirty_layout = True
+        self.set_scroll((self.scroll.x, self.scroll.y + y))
         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.clamp_scroll()
-        self.dirty_layout = True
+        self.set_scroll((self.scroll.x + value[0], self.scroll.y + value[1]))
         return self
 
     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)
+
+        self.set_scroll((new_x, new_y))
         return self
 
     def set_layout(self, layout: Layout) -> Self:
@@ -83,11 +80,15 @@ 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
 
     def get_interactive_children(self) -> list[InteractiveWidget]:
-        return [child for child in self.children if isinstance(child, InteractiveWidget) and not isinstance(child,Container) and child.allow_focus_to_self()]
+        return [child for child in self.get_layout_children() if isinstance(child, InteractiveWidget) and not isinstance(child,Container) and child.allow_focus_to_self()]
+
+    def get_layout_children(self)->list[Widget]:
+        return self.children
 
     def clear_children(self) -> None:
         self.children.clear()
@@ -96,13 +97,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 +124,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,36 +5,40 @@ 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
+        self.click_mask = [True,False,False,False,False]
+        self.is_dragged : bool = False # the widget is following the mouse AND the mouse is in the widget
+        self.is_dragged_outside : bool = False # the widget is following the mouse BUT the mouse is NOT in the widget
         super().__init__(*args, **kwargs)
+    
+    def set_click_mask(self,b1=0,b2=0,b3=0,b4=0,b5=0):
+        self.click_mask = [b1,b2,b3,b4,b5]
 
-    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):
+        super().on_click_down(button)
+        return any(i==j and i== True for i,j in zip(self.is_clicked_down,self.click_mask))
+    
     def do_on_drag(
-        self, drag_start: tuple[float, float], drag_end: tuple[float, float]
+        self, drag_start_pos: tuple[float, float], drag_end_pos: tuple[float, float]
     ) -> None:
-        self.set_position(drag_end[0] - self.offset[0], drag_end[1] - self.offset[1])
+        new_pos = drag_end_pos[0] - self.offset[0], drag_end_pos[1] - self.offset[1]
+        if self.rect.topleft != new_pos:
+            self.set_position(*new_pos)
 
     def update(self, dt: float):
-        if self.drag_action.active and self.is_clicked_down:
-            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:
+        self.is_dragged_outside = any(i==j and i== True for i,j in zip(pygame.mouse.get_pressed(5),self.click_mask))
+        self.is_dragged = any(i==j and i== True for i,j in zip(self.is_clicked_down,self.click_mask))
+
+        if self.is_dragged and self.is_dragged_outside:
+            x, y = self.parent_layer.camera.screen_to_world(pygame.mouse.get_pos())
+            if self.drag_start == None:
                 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
-            self.is_clicked_down = False
+            self.is_clicked_down = [False]*5
         super().update(dt)

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,52 @@ 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
+
+    def set_arrow_color(self,color)-> Self:
+        self.arrow_color = color
+        self.dirty_surface = True
+        return self
+
+    def set_arrow_direction(self,direction:bf.direction)->Self:
+        self.direction = direction
+        self.dirty_surface = True
+        return self
+
+    def set_arrow_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_inner_rect()
+        size = min(r.width, r.height)
+        if size %2 == 0:
+            size -= 1
+        r.width = size
+        r.height = size
+
+        #pixel alignment
+        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_inner_rect().center
+
+        bf.utils.draw_triangle(
+            surface = self.surface,
+            color = self.arrow_color,
+            rect =r,
+            direction = self.direction,
+            width = self.line_width
+
+        )
+        
+
+