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

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
 
@@ -37,7 +39,6 @@ class Label(Shape):
         self.text_rect = pygame.FRect(0, 0, 0, 0)
         # text surface (result of font.render)
         self.text_surface: pygame.Surface = pygame.Surface((0, 0))
-        self.do_caching: bool = False
 
         self.show_text_outline: bool = False
 
@@ -54,21 +55,10 @@ class Label(Shape):
         self.set_autoresize(True)
         self.set_font(force=True)
 
-    @staticmethod
-    def clear_cache():
-        Label._text_cache = {}
-
+        
     def __str__(self) -> str:
         return f"Label({repr(self.text)})"
 
-    def enable_caching(self) -> Self:
-        self.do_caching = True
-        return self
-
-    def disable_caching(self) -> Self:
-        self.do_caching = False
-        return self
-
     def set_text_color(self, color) -> Self:
         self.text_color = color
         self.dirty_surface = True
@@ -148,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:
@@ -196,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
         )
@@ -205,40 +195,32 @@ class Label(Shape):
         return self.text
 
     def _render_font(self, params: dict) -> pygame.Surface:
-        key = tuple(params.values())
-
-        cached_value = Label._text_cache.get(key, None)
 
         if self.draw_mode == bf.drawMode.SOLID:
-            if cached_value is None:
-                params.pop("font_name")
-
-                # save old settings
-                old_italic = self.font_object.get_italic()
-                old_bold = self.font_object.get_bold()
-                old_underline = self.font_object.get_underline()
-
-                # setup font
-                self.font_object.set_italic(self.is_italic)
-                self.font_object.set_bold(self.is_bold)
-                self.font_object.set_underline(self.is_underlined)
-
-                surf = self.font_object.render(**params)
-
-                # reset font
-                self.font_object.set_italic(old_italic)
-                self.font_object.set_bold(old_bold)
-                self.font_object.set_underline(old_underline)
-
-                if self.do_caching:
-                    Label._text_cache[key] = surf
-            else:
-                surf = cached_value
+            params.pop("font_name")
+
+            # save old settings
+            old_italic = self.font_object.get_italic()
+            old_bold = self.font_object.get_bold()
+            old_underline = self.font_object.get_underline()
+
+            # setup font
+            self.font_object.set_italic(self.is_italic)
+            self.font_object.set_bold(self.is_bold)
+            self.font_object.set_underline(self.is_underlined)
+
+            surf = self.font_object.render(**params)
+
+            # reset font
+            self.font_object.set_italic(old_italic)
+            self.font_object.set_bold(old_bold)
+            self.font_object.set_underline(old_underline)
         else:
             params.pop("font_name")
             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:
@@ -267,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:
@@ -276,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])
@@ -301,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)
@@ -309,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
     ):
@@ -334,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()
@@ -342,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

batFramework/gui/layout.py

@@ -2,7 +2,7 @@ import batFramework as bf
 from .widget import Widget
 from .constraints.constraints import *
 from typing import Self, TYPE_CHECKING
-from abc import ABC
+from abc import ABC,abstractmethod
 import pygame
 
 if TYPE_CHECKING:
@@ -26,7 +26,7 @@ class Layout(ABC):
 
     def notify_parent(self) -> None:
         if self.parent:
-            self.parent.dirty_children = True
+            self.parent.dirty_layout = True
 
     def arrange(self) -> None:
         return
@@ -39,7 +39,7 @@ class Layout(ABC):
 
     def get_auto_size(self) -> tuple[float, float]:
         """
-        Returns the final size the container should have (while keeping the the width and height if they are non-resizable)
+        Returns the final size the container should have (while keeping the width and height if they are non-resizable)
         """
         target_size = list(self.get_raw_size())
         if not self.parent.autoresize_w:
@@ -48,25 +48,20 @@ class Layout(ABC):
             target_size[1] = self.parent.rect.h
         return target_size
 
-    def focus_next_child(self) -> None:
-        pass
-
-    def focus_prev_child(self) -> None:
-        pass
-
     def scroll_to_widget(self, widget: Widget) -> None:
-        padded = self.parent.get_padded_rect()
-        r = widget.rect
-        if padded.contains(r):
+        padded = self.parent.get_padded_rect() # le carré intérieur
+        r = widget.rect # le carré du widget = Button
+        if padded.contains(r): # le widget ne depasse pas -> OK
             return
         clamped = r.clamp(padded)
-        dx, dy = clamped.move(-r.x, -r.y).topleft
-        self.parent.scroll_by((-dx, -dy))
+        # clamped.move_ip(-self.parent.rect.x,-self.parent.rect.y)
+        dx,dy = clamped.x - r.x,clamped.y-r.y
 
+        self.parent.scroll_by((-dx, -dy)) # on scroll la différence pour afficher le bouton en entier
+        
     def handle_event(self, event):
         pass
 
-
 class SingleAxisLayout(Layout):
     def focus_next_child(self) -> None:
         l = self.parent.get_interactive_children()
@@ -83,6 +78,7 @@ class SingleAxisLayout(Layout):
         self.scroll_to_widget(focused)
 
 
+
 class Column(SingleAxisLayout):
     def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
         super().__init__()
@@ -126,29 +122,39 @@ class Column(SingleAxisLayout):
         if self.child_constraints:
             for child in self.parent.children:
                 child.add_constraints(*self.child_constraints)
-        self.child_rect = self.parent.get_padded_rect()
-
-        if self.parent.autoresize_w or self.parent.autoresize_h:
-            width, height = self.get_auto_size()
-            if self.parent.rect.size != (width, height):
-                self.parent.set_size((width, height))
-                self.parent.build()
-                self.arrange()
-                return
-        self.child_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
-        y = self.child_rect.top
+        self.children_rect = self.parent.get_padded_rect()
+
+        width, height = self.get_auto_size()
+        if self.parent.autoresize_w and self.parent.rect.w !=width:
+            self.parent.set_size((width,None))
+        if self.parent.autoresize_h and self.parent.rect.h !=height:
+            self.parent.set_size((None,height))
+        
+        # if self.parent.dirty_shape:
+            # print("parent set dirty shape")
+            # self.parent.dirty_layout = True
+            # self.parent.apply_updates()
+            # self.arrange()
+            # return
+            
+        self.children_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
+        y = self.children_rect.top
         for child in self.parent.children:
-            child.set_position(self.child_rect.x, y)
+            child.set_position(self.children_rect.x, y)
             y += child.get_min_required_size()[1] + self.gap
 
     def handle_event(self, event):
-        if self.parent.autoresize_h or not self.parent.visible:
-            return
-
         if not self.parent.children:
             return
 
-        if event.type == pygame.MOUSEBUTTONDOWN:
+        if event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_DOWN:
+                self.focus_next_child()
+            elif event.key == pygame.K_UP:
+                self.focus_prev_child()
+            else:
+                return
+        elif event.type == pygame.MOUSEBUTTONDOWN:
             r = self.parent.get_root()
             if not r:
                 return
@@ -162,9 +168,12 @@ class Column(SingleAxisLayout):
                     self.parent.scroll_by((0, 10))
                 else:
                     return
-                event.consumed = True
                 self.parent.clamp_scroll()
-
+            else:
+                return
+        else:
+            return
+        event.consumed = True
 
 class Row(SingleAxisLayout):
     def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
@@ -210,7 +219,7 @@ class Row(SingleAxisLayout):
         if self.child_constraints:
             for child in self.parent.children:
                 child.add_constraints(*self.child_constraints)
-        self.child_rect = self.parent.get_padded_rect()
+        self.children_rect = self.parent.get_padded_rect()
 
         if self.parent.autoresize_w or self.parent.autoresize_h:
             width, height = self.get_auto_size()
@@ -219,20 +228,25 @@ class Row(SingleAxisLayout):
                 self.parent.build()
                 self.arrange()
                 return
-        self.child_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
-        x = self.child_rect.left
+        self.children_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
+        x = self.children_rect.left
         for child in self.parent.children:
-            child.set_position(x, self.child_rect.y)
+            child.set_position(x, self.children_rect.y)
             x += child.get_min_required_size()[0] + self.gap
 
     def handle_event(self, event):
-        if self.parent.autoresize_w or not self.parent.visible:
-            return
-
         if not self.parent.children:
             return
 
-        if event.type == pygame.MOUSEBUTTONDOWN:
+        if event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_RIGHT:
+                self.focus_next_child()
+            elif event.key == pygame.K_LEFT:
+                self.focus_prev_child()
+            else:
+                return
+                
+        elif event.type == pygame.MOUSEBUTTONDOWN:
             r = self.parent.get_root()
             if not r:
                 return
@@ -245,5 +259,327 @@ class Row(SingleAxisLayout):
                     self.parent.scroll_by((10, 0))
                 else:
                     return
-                event.consumed = True
                 self.parent.clamp_scroll()
+            else:
+                return
+        else:
+            return
+
+
+        event.consumed = True
+
+class RowFill(Row):
+    def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
+        super().__init__(gap, spacing)
+
+    def arrange(self) -> None:
+        if self.parent.autoresize_h :
+           super().arrange() 
+           return
+        if not self.parent or not self.parent.children:
+            return
+
+        if self.child_constraints:
+            for child in self.parent.children:
+                child.add_constraints(*self.child_constraints)
+        self.children_rect = self.parent.get_padded_rect()
+
+        if self.parent.autoresize_w or self.parent.autoresize_h:
+            width, height = self.get_auto_size()
+            if self.parent.rect.size != (width, height):
+                self.parent.set_size((width, height))
+                self.parent.build()
+                self.arrange()
+                return
+
+        self.children_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
+        
+        # Calculate the width each child should fill
+        available_width = self.children_rect.width - (len(self.parent.children) - 1) * self.gap
+        child_width = available_width / len(self.parent.children)
+        
+        x = self.children_rect.left
+        for child in self.parent.children:
+            child.set_position(x, self.children_rect.y)
+            child.set_autoresize_w(False)
+            child.set_size((child_width, None))
+            x += child_width + self.gap
+
+    def get_raw_size(self) -> tuple[float, float]:
+        """Calculate total size with children widths filling the available space."""
+        if self.parent.autoresize_h :
+           return super().get_raw_size()
+        len_children = len(self.parent.children)
+        if not len_children:
+            return self.parent.rect.size
+        parent_height = max(c.get_min_required_size()[1] for c in self.parent.children)
+        target_rect = self.parent.inflate_rect_by_padding((0, 0, self.children_rect.width, parent_height))
+        return target_rect.size
+
+
+class ColumnFill(Column):
+    def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
+        super().__init__(gap, spacing)
+
+    def arrange(self) -> None:
+        if self.parent.autoresize_h :
+           super().arrange() 
+           return
+        if not self.parent or not self.parent.children:
+            return
+        if self.child_constraints:
+            for child in self.parent.children:
+                child.add_constraints(*self.child_constraints)
+        self.children_rect = self.parent.get_padded_rect()
+
+        if self.parent.autoresize_w or self.parent.autoresize_h:
+            width, height = self.get_auto_size()
+            if self.parent.rect.size != (width, height):
+                self.parent.set_size((width, height))
+                self.parent.build()
+                self.arrange()
+                return
+
+        self.children_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
+
+        # Calculate the height each child should fill
+        available_height = self.children_rect.height - (len(self.parent.children) - 1) * self.gap
+        child_height = available_height / len(self.parent.children)
+
+        y = self.children_rect.top
+        for child in self.parent.children:
+            child.set_position(self.children_rect.x, y)
+            child.set_autoresize_h(False)
+            child.set_size((None, child_height))
+            y += child_height + self.gap
+
+    def get_raw_size(self) -> tuple[float, float]:
+        """Calculate total size with children heights filling the available space."""
+        if self.parent.autoresize_w :
+           return super().get_raw_size()
+        len_children = len(self.parent.children)
+        if not len_children:
+            return self.parent.rect.size
+        parent_width = max(c.get_min_required_size()[0] for c in self.parent.children)
+        target_rect = self.parent.inflate_rect_by_padding((0, 0, parent_width, self.children_rect.height))
+        return target_rect.size
+
+
+
+class DoubleAxisLayout(Layout):
+    """Abstract layout class for layouts that arrange widgets in two dimensions."""
+
+    @abstractmethod
+    def arrange(self) -> None:
+        """Arrange child widgets across both axes, implementation required in subclasses."""
+        pass
+
+    def focus_up_child(self) -> None:...
+    def focus_down_child(self) -> None:...
+    def focus_right_child(self) -> None:...
+    def focus_left_child(self) -> None:...
+
+
+
+class Grid(DoubleAxisLayout):
+    def __init__(self, rows: int, cols: int, gap: int = 0):
+        super().__init__()
+        self.rows = rows
+        self.cols = cols
+        self.gap = gap
+
+    def set_gap(self, value: int) -> Self:
+        self.gap = value
+        self.notify_parent()
+        return self
+
+    def set_dimensions(self, rows: int, cols: int) -> Self:
+        self.rows = rows
+        self.cols = cols
+        self.notify_parent()
+        return self
+
+    def get_raw_size(self) -> tuple[float, float]:
+        """Calculate raw size based on the max width and height needed to fit all children."""
+        if not self.parent.children:
+            return self.parent.rect.size
+
+        # Calculate necessary width and height for the grid
+        max_child_width = max(child.get_min_required_size()[0] for child in self.parent.children)
+        max_child_height = max(child.get_min_required_size()[1] for child in self.parent.children)
+        
+        grid_width = self.cols * max_child_width + (self.cols - 1) * self.gap
+        grid_height = self.rows * max_child_height + (self.rows - 1) * self.gap
+        target_rect = self.parent.inflate_rect_by_padding((0, 0, grid_width, grid_height))
+        
+        return target_rect.size
+
+    def arrange(self) -> None:
+        """Arrange widgets in a grid with specified rows and columns."""
+        if not self.parent or not self.parent.children:
+            return
+
+        if self.child_constraints:
+            for child in self.parent.children:
+                child.add_constraints(*self.child_constraints)
+
+
+        if self.parent.autoresize_w or self.parent.autoresize_h:
+            width, height = self.get_auto_size()
+            if self.parent.rect.size != (width, height):
+                self.parent.set_size((width, height))
+                self.parent.build()
+                self.arrange()
+                return
+
+        self.child_rect = self.parent.get_padded_rect()
+
+        # Calculate cell width and height based on parent size and gaps
+        cell_width = (self.child_rect.width - (self.cols - 1) * self.gap) / self.cols
+        cell_height = (self.child_rect.height - (self.rows - 1) * self.gap) / self.rows
+
+        for i, child in enumerate(self.parent.children):
+            row = i // self.cols
+            col = i % self.cols
+            x = self.child_rect.left + col * (cell_width + self.gap)
+            y = self.child_rect.top + row * (cell_height + self.gap)
+
+            child.set_position(x, y)
+            child.set_size((cell_width, cell_height))
+
+    def handle_event(self, event):
+
+        if event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_DOWN:
+                self.focus_down_child()
+            elif event.key == pygame.K_UP:
+                self.focus_up_child()
+            elif event.key == pygame.K_LEFT:
+                self.focus_left_child()
+            elif event.key == pygame.K_RIGHT:
+                self.focus_right_child()         
+            else:
+                return
+        elif event.type == pygame.MOUSEBUTTONDOWN:
+            r = self.parent.get_root()
+            if not r:
+                return
+
+            if self.parent.rect.collidepoint(
+                r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
+            ):
+                if event.button == 4:
+                    self.parent.scroll_by((0, -10))
+                elif event.button == 5:
+                    self.parent.scroll_by((0, 10))
+                else:
+                    return
+                self.parent.clamp_scroll()
+            else:
+                return
+        else:
+            return
+        event.consumed = True
+
+    def focus_down_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        new_index = self.parent.focused_index + self.cols
+        if new_index >= len(l):
+            return
+        self.parent.focused_index = new_index
+        focused = l[self.parent.focused_index]
+        focused.get_focus()
+        self.scroll_to_widget(focused)
+
+    def focus_up_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        new_index = self.parent.focused_index - self.cols
+        if new_index < 0:
+            return
+        self.parent.focused_index = new_index
+        focused = l[self.parent.focused_index]
+        focused.get_focus()
+        self.scroll_to_widget(focused)
+
+    def focus_left_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        new_index = (self.parent.focused_index % self.cols) -1
+        if new_index < 0:
+            return
+        self.parent.focused_index -=1
+        focused = l[self.parent.focused_index]
+        focused.get_focus()
+        self.scroll_to_widget(focused)
+
+    def focus_right_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        new_index = (self.parent.focused_index % self.cols) +1
+        if new_index >= self.cols or self.parent.focused_index+1 >= len(l):
+            return
+        self.parent.focused_index += 1
+        focused = l[self.parent.focused_index]
+        focused.get_focus()
+        self.scroll_to_widget(focused)
+
+
+class GridFill(Grid):
+    def __init__(self, rows: int, cols: int, gap: int = 0):
+        super().__init__(rows,cols,gap)
+
+    def arrange(self) -> None:
+        """Arrange widgets to fill each grid cell, adjusting to available space."""
+        if not self.parent or not self.parent.children:
+            return
+
+        if self.child_constraints:
+            for child in self.parent.children:
+                child.add_constraints(*self.child_constraints)
+
+        self.child_rect = self.parent.get_padded_rect()
+
+        # If autoresize is enabled, calculate required dimensions
+        if self.parent.autoresize_w or self.parent.autoresize_h:
+            width, height = self.get_auto_size()
+            if self.parent.rect.size != (width, height):
+                self.parent.set_size((width, height))
+                self.parent.build()
+                self.arrange()
+                return
+
+        # Adjust for scrolling offset
+        self.child_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
+
+        # Calculate cell dimensions based on available space
+        available_width = self.child_rect.width - (self.cols - 1) * self.gap
+        available_height = self.child_rect.height - (self.rows - 1) * self.gap
+        cell_width = available_width / self.cols
+        cell_height = available_height / self.rows
+
+        # Position each child in the grid
+        for index, child in enumerate(self.parent.children):
+            row = index // self.cols
+            col = index % self.cols
+            x = self.child_rect.left + col * (cell_width + self.gap)
+            y = self.child_rect.top + row * (cell_height + self.gap)
+
+            child.set_position(x, y)
+            child.set_autoresize_w(False)
+            child.set_autoresize_h(False)
+            child.set_size((cell_width, cell_height))
+
+    def get_raw_size(self) -> tuple[float, float]:
+        """Calculate the grid’s raw size based on child minimums and the grid dimensions."""
+        if not self.parent.children:
+            return self.parent.rect.size
+
+        # Determine minimum cell size required by the largest child
+        max_child_width = max(child.get_min_required_size()[0] for child in self.parent.children)
+        max_child_height = max(child.get_min_required_size()[1] for child in self.parent.children)
+
+        # Calculate total required size for the grid
+        grid_width = self.cols * max_child_width + (self.cols - 1) * self.gap
+        grid_height = self.rows * max_child_height + (self.rows - 1) * self.gap
+
+        # Adjust for padding and return
+        target_rect = self.parent.inflate_rect_by_padding((0, 0, grid_width, grid_height))
+        return target_rect.size