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

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.Drawable.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/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),
         )

batFramework/gui/label.py

@@ -10,12 +10,14 @@ class Label(Shape):
     def __init__(self, text: str = "") -> None:
         self.text = text
 
+        self.scroll :pygame.Vector2 = pygame.Vector2(0,0)
+
         self.resized_flag: bool = False
 
         # Enable/Disable antialiasing
         self.antialias: bool = bf.FontManager().DEFAULT_ANTIALIAS
 
-        self.text_size = bf.FontManager().DEFAULT_TEXT_SIZE
+        self.text_size = bf.FontManager().DEFAULT_FONT_SIZE
 
         self.auto_wraplength: bool = False
 
@@ -53,6 +55,7 @@ class Label(Shape):
         self.set_autoresize(True)
         self.set_font(force=True)
 
+        
     def __str__(self) -> str:
         return f"Label({repr(self.text)})"
 
@@ -135,7 +138,7 @@ class Label(Shape):
     def get_debug_outlines(self):
         if self.visible:
             offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-            yield (self.text_rect.move(self.rect.x - offset[0],self.rect.y - offset[1]), "purple")
+            yield (self.text_rect.move(self.rect.x - offset[0] - self.scroll.x,self.rect.y - offset[1] - self.scroll.y), "purple")
         yield from super().get_debug_outlines()
 
     def set_font(self, font_name: str = None, force: bool = False) -> Self:
@@ -183,7 +186,7 @@ class Label(Shape):
         if not self.text_rect:
             self.text_rect.size = self._get_text_rect_required_size()
         res = self.inflate_rect_by_padding((0, 0, *self.text_rect.size)).size
-
+        
         return res[0] if self.autoresize_w else self.rect.w, (
             res[1] if self.autoresize_h else self.rect.h
         )
@@ -217,6 +220,7 @@ class Label(Shape):
             surf = self.font_object.render(**params)
 
         return surf
+        
     def _get_text_rect_required_size(self):
         font_height = self.font_object.get_linesize()
         if not self.text:
@@ -245,7 +249,6 @@ class Label(Shape):
         self.text_rect.size = self._get_text_rect_required_size()
         # self.text_rect.w = ceil(self.text_rect.w)
         # self.text_rect.h = ceil(self.text_rect.h) 
-
         if self.autoresize_h or self.autoresize_w:
             target_rect = self.inflate_rect_by_padding((0, 0, *self.text_rect.size))
             if not self.autoresize_w:
@@ -254,7 +257,7 @@ class Label(Shape):
                 target_rect.h = self.rect.h
             if self.rect.size != target_rect.size:
                 self.set_size(target_rect.size)
-                self.build()
+                self.apply_updates()
                 return
         offset = self._get_outline_offset() if self.show_text_outline else (0,0)
         padded = self.get_padded_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
@@ -279,7 +282,6 @@ class Label(Shape):
         }
 
         self.text_surface = self._render_font(params)
-
         if self.show_text_outline:
             self.text_outline_surface = (
                 pygame.mask.from_surface(self.text_surface)
@@ -287,19 +289,28 @@ class Label(Shape):
                 .to_surface(setcolor=self.text_outline_color, unsetcolor=(0, 0, 0, 0))
             )
 
-        l = []
         outline_offset = self._get_outline_offset() if self.show_text_outline else (0,0)
 
+
+        # prepare fblit list
+        l = []
         if self.show_text_outline:
             l.append(
                 (self.text_outline_surface,
-                (self.text_rect.x - outline_offset[0],self.text_rect.y - outline_offset[1]))
+                (self.text_rect.x - outline_offset[0] - self.scroll.x,self.text_rect.y - outline_offset[1] - self.scroll.y))
             )
         l.append(
-            (self.text_surface, self.text_rect)
+            (self.text_surface, self.text_rect.move(-self.scroll))
         )
+
+        # clip surface
+        
+        old = self.surface.get_clip()
+        self.surface.set_clip(self.get_padded_rect().move(-self.rect.x,-self.rect.y))
         self.surface.fblits(l)
+        self.surface.set_clip(old)
 
+        
     def align_text(
         self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
     ):
@@ -312,6 +323,8 @@ class Label(Shape):
         text_rect.__setattr__(alignment.value, pos)
         text_rect.y = ceil(text_rect.y)
 
+
+
     def build(self) -> None:
         super().build()
         self._build_layout()
@@ -320,3 +333,6 @@ class Label(Shape):
         super().paint()
         if self.font_object:
             self._paint_text()
+
+    # def set_alignment(self, alignment: bf.alignment) -> Self:
+    #     return self