batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

batFramework/gui/interactiveWidget.py

@@ -18,10 +18,11 @@ def children_has_focus(widget)->bool:
 
 
 class InteractiveWidget(Widget):
+    __focus_effect_cache = {}
     def __init__(self, *args, **kwargs) -> None:
         self.is_focused: bool = False
         self.is_hovered: bool = False
-        self.is_clicked_down: bool = False
+        self.is_clicked_down: list[bool] = [False]*5
         self.focused_index = 0
         self.focusable = True
         super().__init__(*args, **kwargs)
@@ -56,7 +57,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,98 +65,127 @@ 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 propagation
+        """
+        return self.do_on_key_down(key)
 
     def on_key_up(self, key) -> bool:
+        """
+        return True to stop event propagation
+        """
         return self.do_on_key_up(key)
 
-    def do_on_key_down(self, key) -> bool:
-        return False
-
-    def do_on_key_up(self, key) -> bool:
-        return False
-
     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 propagation
+        """
+        return False
+
+    def do_on_key_up(self, key) -> bool:
+        """
+        return True to stop event propagation
+        """
+        return False
+
     def on_click_down(self, button: int) -> bool:
-        self.is_clicked_down = True
+        """
+        return True to stop event propagation
+        """
+        if button < 1 or button > 5 : return False
+        self.is_clicked_down[button-1] = True
         return self.do_on_click_down(button)
 
     def on_click_up(self, button: int) -> bool:
-        self.is_clicked_down = False
+        """
+        return True to stop event propagation
+        """
+        if button < 1 or button > 5 : return False
+        self.is_clicked_down[button-1] = False
         return self.do_on_click_up(button)
 
-    def do_on_click_down(self, button: int) -> bool:
-        return False
+    def do_on_click_down(self, button: int) -> None:
+        return 
 
-    def do_on_click_up(self, button: int) -> bool:
-        return False
+    def do_on_click_up(self, button: int) -> None:
+        return 
 
     def on_enter(self) -> None:
         self.is_hovered = True
@@ -163,7 +193,7 @@ class InteractiveWidget(Widget):
 
     def on_exit(self) -> None:
         self.is_hovered = False
-        self.is_clicked_down = False
+        self.is_clicked_down = [False]*5
         self.do_on_exit()
 
     def do_on_enter(self) -> None:
@@ -182,39 +212,28 @@ class InteractiveWidget(Widget):
         pass
 
     def draw_focused(self, camera: bf.Camera) -> None:
+        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
+        inner.w = round(inner.w)
+        inner.h = round(inner.h)
+
+        surface = InteractiveWidget.__focus_effect_cache.get(inner.size)
+        if surface is None:
+            surface = pygame.Surface(inner.size)
+            InteractiveWidget.__focus_effect_cache[inner.size] = surface
+
+        surface.set_colorkey((0,0,0))
+        pygame.draw.rect(surface, "white", inner, 2, *self.border_radius)
+        pygame.draw.rect(surface, "black", inner.inflate(-1 * min(16,inner.w*0.75),0), 2)
+        pygame.draw.rect(surface, "black", inner.inflate(0,-1 * min(16,inner.h*0.75)), 2)
+        inner.center = screen_rect.center
+        camera.surface.blit(surface,inner)
 
-        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

@@ -1,7 +1,7 @@
 import batFramework as bf
 import pygame
 from .shape import Shape
-from typing import Self
+from typing import Literal, Self,Union
 from math import ceil
 
 class Label(Shape):
@@ -10,6 +10,10 @@ class Label(Shape):
     def __init__(self, text: str = "") -> None:
         self.text = text
 
+        # Allows scrolling the text
+        self.allow_scroll : bool = True
+
+        # Scroll variable
         self.scroll :pygame.Vector2 = pygame.Vector2(0,0)
 
         self.resized_flag: bool = False
@@ -31,6 +35,7 @@ class Label(Shape):
 
         self._text_outline_mask = pygame.Mask((3, 3), fill=True)
 
+        self.line_alignment = pygame.FONT_LEFT
         # font name (given when loaded by utils) to use for the text
         self.font_name = None
         # reference to the font object
@@ -59,11 +64,23 @@ class Label(Shape):
     def __str__(self) -> str:
         return f"Label({repr(self.text)})"
 
+
+    def set_allow_scroll(self, value:bool)->Self:
+        if self.allow_scroll == value: return self
+        self.allow_scroll = value
+        self.dirty_shape = True
+        return self
+
     def set_text_color(self, color) -> Self:
         self.text_color = color
         self.dirty_surface = True
         return self
 
+    def set_line_alignment(self, alignment: Union[Literal["left"], Literal["right"], Literal["center"]]) -> Self:
+        self.line_alignment = alignment
+        self.dirty_surface = True
+        return self
+
     def set_italic(self, value: bool) -> Self:
         if value == self.is_italic:
             return self
@@ -136,10 +153,12 @@ class Label(Shape):
         return self
 
     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.scroll.x,self.rect.y - offset[1] - self.scroll.y), "purple")
         yield from super().get_debug_outlines()
+        if self.visible:
+            yield (self.text_rect.move(self.rect.x - self.scroll.x,self.rect.y - self.scroll.y), "purple")
+            
+            # offset = self._get_outline_offset() if self.show_text_outline else (0,0)
+            # yield (self.text_rect.move(self.rect.x - offset[0] - self.scroll.x,self.rect.y - offset[1] - self.scroll.y), "purple")
 
     def set_font(self, font_name: str = None, force: bool = False) -> Self:
         if font_name == self.font_name and not force:
@@ -153,13 +172,12 @@ class Label(Shape):
         return self
 
     def set_text_size(self, text_size: int) -> Self:
-        text_size = round(text_size / 2) * 2
+        text_size = (text_size // 2) * 2
         if text_size == self.text_size:
             return self
         self.text_size = text_size
         self.font_object = bf.FontManager().get_font(self.font_name, self.text_size)
-        if self.autoresize_h or self.autoresize_w:
-            self.dirty_shape = True
+        self.dirty_shape = True
         return self
 
     def get_text_size(self) -> int:
@@ -181,15 +199,9 @@ class Label(Shape):
         return self
 
     def get_min_required_size(self) -> tuple[float, float]:
-        if not (self.autoresize_w or self.autoresize_h):
-            return self.rect.size
-        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
-        )
+        return self.expand_rect_with_padding(
+            (0, 0, *self._get_text_rect_required_size())
+        ).size
 
     def get_text(self) -> str:
         return self.text
@@ -203,28 +215,32 @@ class Label(Shape):
             old_italic = self.font_object.get_italic()
             old_bold = self.font_object.get_bold()
             old_underline = self.font_object.get_underline()
-
+            old_align = self.font_object.align
             # 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)
-
+            self.font_object.align = self.line_alignment
             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)
+            self.font_object.align = old_align
         else:
             params.pop("font_name")
             surf = self.font_object.render(**params)
 
         return surf
-        
+
+    def _get_outline_offset(self)->tuple[int,int]:
+        mask_size = self._text_outline_mask.get_size()
+        return  mask_size[0]//2,mask_size[1]//2
+    
     def _get_text_rect_required_size(self):
-        font_height = self.font_object.get_linesize()
+        font_height = self.font_object.get_ascent() - self.font_object.get_descent()
         if not self.text:
-            # font_height = self.font_object.get_ascent() - self.font_object.get_ascent()
             size = (0,font_height)
         else:
             tmp_text = self.text
@@ -236,49 +252,43 @@ class Label(Shape):
                 "antialias": self.antialias,
                 "color": self.text_color,
                 "bgcolor": None,  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": int(self.get_padded_width()) if self.auto_wraplength and not self.autoresize_w else 0,
+                "wraplength": int(self.get_inner_width()) if self.auto_wraplength and not self.autoresize_w else 0,
             }
 
             size = self._render_font(params).get_size()
             size = size[0],max(font_height,size[1])
+            
+        # print(self.text,size)
         s = self._get_outline_offset() if self.show_text_outline else (0,0)
         return size[0] + s[0]*2, size[1] + s[1]*2
 
-    def _build_layout(self) -> None:
+    def _build_layout(self) -> bool:
+        ret = False
+        target_size = self.resolve_size(self.get_min_required_size())
 
-        # print(self.text_rect.size,self._get_text_rect_required_size(),repr(self.text))
-        self.text_rect.size = self._get_text_rect_required_size()
+        if self.rect.size != target_size :
+            self.set_size(target_size)
+            ret = True
+            # self.apply_post_updates(skip_draw=True)
+            # return True
 
-        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:
-                target_rect.w = self.rect.w
-            if not self.autoresize_h:
-                target_rect.h = self.rect.h
-            if self.rect.size != target_rect.size:
-                # print("Size not good ! ",self.rect.size,target_rect.size,repr(self.text))
-                self.set_size(target_rect.size)
-                self.apply_updates()
-
-        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])
+        self.text_rect.size = self._get_text_rect_required_size()
+        padded = self.get_local_inner_rect()
         self.align_text(self.text_rect, padded, self.alignment)
-
-    def _get_outline_offset(self)->tuple[int,int]:
-        mask_size = self._text_outline_mask.get_size()
-        return  mask_size[0]//2,mask_size[1]//2
+        return ret
 
     def _paint_text(self) -> None:
         if self.font_object is None:
             print(f"No font for widget with text : '{self}' :(")
             return
+        wrap = int(self.get_inner_width()) if self.auto_wraplength and not self.autoresize_w else 0
         params = {
             "font_name": self.font_object.name,
             "text": self.text,
             "antialias": self.antialias,
             "color": self.text_color,
-            "bgcolor": None,  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-            "wraplength": int(self.get_padded_width()) if self.auto_wraplength and not self.autoresize_w else 0,
+            "bgcolor": None, 
+            "wraplength": wrap,
         }
 
         self.text_surface = self._render_font(params)
@@ -289,27 +299,22 @@ class Label(Shape):
                 .to_surface(setcolor=self.text_outline_color, unsetcolor=(0, 0, 0, 0))
             )
 
-        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.scroll.x,self.text_rect.y - outline_offset[1] - self.scroll.y))
-            )
-        l.append(
-            (self.text_surface, self.text_rect.move(-self.scroll))
-        )
+            outline_offset = list(self._get_outline_offset())
+            outline_offset[0]-=self.scroll.x
+            outline_offset[1]-=self.scroll.y
+            l = [
+                (self.text_outline_surface,(self.text_rect.x  - self.scroll.x,self.text_rect.y - self.scroll.y)),
+                (self.text_surface, self.text_rect.move(*outline_offset))
+            ]
+        else:
+            l = [(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.set_clip(self.get_local_inner_rect())
         self.surface.fblits(l)
         self.surface.set_clip(old)
-
         
     def align_text(
         self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
@@ -323,12 +328,16 @@ class Label(Shape):
         text_rect.__setattr__(alignment.value, pos)
         text_rect.y = ceil(text_rect.y)
 
-
-
-    def build(self) -> None:
+    def build(self) -> bool:
+        """
+        return True if size changed
+        """
+        
+        size_changed = self._build_layout()
         super().build()
-        self._build_layout()
-
+        return size_changed
+        
+        
     def paint(self) -> None:
         super().paint()
         if self.font_object: