batframework 1.0.9a10__py3-none-any.whl → 1.0.10__py3-none-any.whl

batFramework/gui/interactiveWidget.py

@@ -1,239 +1,22 @@
 from .widget import Widget
-from typing import Self
-from typing import TYPE_CHECKING
-import pygame
-from math import cos,floor,ceil
-
-if TYPE_CHECKING:
-    from .container import Container
-import batFramework as bf
-
-def children_has_focus(widget)->bool:
-    if isinstance(widget,InteractiveWidget) and widget.is_focused:
-        return True
-    for child in widget.children:
-        if children_has_focus(child):
-            return True
-    return False
-
 
 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: list[bool] = [False]*5
-        self.focused_index = 0
+    def __init__(self,*args,**kwargs):
+        super().__init__(convert_alpha = True)
         self.focusable = True
-        super().__init__(*args, **kwargs)
-
-    def set_focusable(self, value: bool) -> Self:
-        self.focusable = value
-        return self
-
-    def allow_focus_to_self(self) -> bool:
-        return self.visible
+        self.is_focused : bool = False
 
-    def get_focus(self) -> bool:
-        if self.focusable and ((r := self.get_root()) is not None):
-            r.focus_on(self)
-            if self.parent and isinstance(self.parent, InteractiveWidget):
-                self.parent.set_focused_child(self)
-            return True
-        return False
+    def get_focus(self)->bool:
+        if self.parent is None or not self.focusable: return False
+        self.get_root().focus_on(self)
 
-    def lose_focus(self) -> bool:
-        if self.is_focused and ((r := self.get_root()) is not None):
-            r.focus_on(None)
-            return True
-        return False
-
-    def set_parent(self, parent: Widget) -> Self:
-        if parent is None and children_has_focus(self):
-            self.get_root().clear_focused()
-            # pass focus on
-
-        return super().set_parent(parent)
-
-    def on_get_focus(self) -> None:
+    def on_get_focus(self)->None:
         self.is_focused = True
-        if isinstance(self.parent,bf.gui.Container):
-            self.parent.layout.scroll_to_widget(self) 
-        self.do_on_get_focus()
 
-    def on_lose_focus(self) -> None:
+    def on_lose_focus(self)->None:
         self.is_focused = False
-        self.do_on_lose_focus()
-
         
-
-    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 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()
-
-    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()
-
-
-    
-    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_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:
-        """
-        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:
-        """
-        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) -> None:
-        return 
-
-    def do_on_click_up(self, button: int) -> None:
-        return 
-
-    def on_enter(self) -> None:
-        self.is_hovered = True
-        self.do_on_enter()
-
-    def on_exit(self) -> None:
-        self.is_hovered = False
-        self.is_clicked_down = [False]*5
-        self.do_on_exit()
-
-    def do_on_enter(self) -> None:
-        pass
-
-    def do_on_exit(self) -> None:
-        pass
-
-    def on_mouse_motion(self, x, y) -> None:
-        self.do_on_mouse_motion(x, y)
-
-    def do_on_mouse_motion(self, x, y) -> None:
-        pass
-
-    def set_focused_child(self, child: "InteractiveWidget"):
-        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)
-
+    def lose_focus(self)->bool:
+        if self.is_focused and self.parent is not None:
+            self.get_root().focus_on(None)
+            

batFramework/gui/label.py

@@ -1,344 +1,110 @@
 import batFramework as bf
 import pygame
 from .shape import Shape
-from typing import Literal, Self,Union
-from math import ceil
+from typing import Self
 
 class Label(Shape):
-    _text_cache = {}
-
-    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
-
+    def __init__(self,text:str) -> None:   
+        self._text = ""
         # Enable/Disable antialiasing
-        self.antialias: bool = bf.FontManager().DEFAULT_ANTIALIAS
-
-        self.text_size = bf.FontManager().DEFAULT_FONT_SIZE
-
-        self.auto_wraplength: bool = False
-
-        self.alignment: bf.alignment = bf.alignment.CENTER
-
-        self.text_color: tuple[int, int, int] | str = "black"
-
-        self.text_outline_color: tuple[int, int, int] | str = "gray50"
-
-        self.text_outline_surface: pygame.Surface = None
-
-        self._text_outline_mask = pygame.Mask((3, 3), fill=True)
-
-        self.line_alignment = pygame.FONT_LEFT
+        self._antialias : bool = True
+        
+        self._text_size = bf.const.DEFAULT_TEXT_SIZE
+        
+        self._text_color : tuple[int,int,int]|str = "black"
         # font name (given when loaded by utils) to use for the text
-        self.font_name = None
+        self._font_name = None
         # reference to the font object
-        self.font_object = None
+        self._font_object = None
         # Rect containing the text of the label
-        self.text_rect = pygame.FRect(0, 0, 0, 0)
+        self._text_rect = None
         # text surface (result of font.render)
-        self.text_surface: pygame.Surface = pygame.Surface((0, 0))
-
-        self.show_text_outline: bool = False
-
-        self.is_italic: bool = False
-
-        self.is_bold: bool = False
-
-        self.is_underlined: bool = False
-
-        super().__init__((0, 0))
-        self.set_padding((10, 4))
+        self._text_surface : pygame.Surface | None= None 
+        super().__init__(width=0,height=0)
+        self.set_padding((10,4))
         self.set_debug_color("blue")
-        self.set_color("gray50")
+        self.set_color("white")
         self.set_autoresize(True)
         self.set_font(force=True)
+        self.set_text(text)
 
-        
-    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
+    def set_text_color(self,color)->Self:
+        self._text_color = color
+        self.build()
         return self
 
-    def set_text_color(self, color) -> Self:
-        self.text_color = color
-        self.dirty_surface = True
-        return self
+    def to_string_id(self)->str:
+        return f"Label({self._text})"
 
-    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
-        self.is_italic = value
-        if self.autoresize_h or self.autoresize_w:
-            self.dirty_shape = True
-        else:
-            self.dirty_surface = True
-        return self
+    def get_bounding_box(self):
+        yield from super().get_bounding_box()
+        if self._text_rect : yield self._text_rect.move(*self.rect.topleft)
 
-    def set_bold(self, value: bool) -> Self:
-        if value == self.is_bold:
-            return self
-        self.is_bold = value
-        if self.autoresize_h or self.autoresize_w:
-            self.dirty_shape = True
-        else:
-            self.dirty_surface = True
+    def set_font(self,font_name:str=None,force:bool = False)-> "Label":
+        if font_name == self._font_name and not force: return self
+        self._font_name = font_name
+        self._font_object = bf.utils.get_font(self._font_name,self._text_size)
+        self.build()
         return self
 
-    def set_underlined(self, value: bool) -> Self:
-        if value == self.is_underlined:
-            return self
-        self.is_underlined = value
-        self.dirty_surface = True
+    def set_text_size(self,text_size:int) -> "Label":
+        text_size = round(text_size/2) * 2
+        if text_size == self._text_size : return self
+        self._text_size = text_size
+        self._font_object = bf.utils.get_font(self._font_name,self._text_size)
+        self.build()
         return self
 
-    def set_text_outline_mask_size(self,size:tuple[int,int])->Self:
-        old_size = self._text_outline_mask.get_size()
-        m = [[self._text_outline_mask.get_at((x,y)) for x in range(min(old_size[0],size[0]))] for y in range(min(old_size[1],size[1]))]
-        self._text_outline_mask = pygame.Mask(size, fill=True)
-        self.set_text_outline_matrix(m)
-        return self
-
-    def set_text_outline_matrix(self, matrix: list[list[0 | 1]]) -> Self:
-        if matrix is None:
-            matrix = [[0 for _ in range(3)] for _ in range(3)]
-        for y in range(3):
-            for x in range(3):
-                self._text_outline_mask.set_at((x, y), matrix[2 - y][2 - x])
-        self.dirty_shape = True
-        return self
-
-    def set_text_outline_color(self, color) -> Self:
-        self.text_outline_color = color
-        self.dirty_surface = True
-        return self
-
-    def enable_text_outline(self) -> Self:
-        self.show_text_outline = True
-        self.dirty_shape = True
-        return self
+    def get_text_size(self)-> int:
+        return self._text_size
 
-    def disable_text_outline(self) -> Self:
-        self.show_text_outline = False
-        self.dirty_shape = True
-        return self
+    def is_antialias(self)->bool:
+        return self._antialias
 
-    def set_alignment(self, alignment: bf.alignment) -> Self:
-        self.alignment = alignment
-        self.dirty_surface = True
+    def set_antialias(self,value:bool)->"Label":
+        self._antialias = value
+        self.build()
         return self
 
-    def set_auto_wraplength(self, val: bool) -> Self:
-        self.auto_wraplength = val
-        if self.autoresize_h or self.autoresize_w:
-            self.dirty_shape = True
-        else:
-            self.dirty_surface = True
+    def set_text(self,text:str) -> "Label":
+        if text == self._text : return self
+        self._text = text
+        self.build()
         return self
-
-    def get_debug_outlines(self):
-        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:
-            return self
-        self.font_name = font_name
-        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
-        else:
-            self.dirty_surface = True
-        return self
-
-    def set_text_size(self, text_size: int) -> Self:
-        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)
-        self.dirty_shape = True
-        return self
-
-    def get_text_size(self) -> int:
-        return self.text_size
-
-    def is_antialias(self) -> bool:
-        return self.antialias
-
-    def set_antialias(self, value: bool) -> Self:
-        self.antialias = value
-        self.dirty_surface = True
-        return self
-
-    def set_text(self, text: str) -> Self:
-        if text == self.text:
-            return self
-        self.text = text
-        self.dirty_shape = True
-        return self
-
-    def get_min_required_size(self) -> tuple[float, float]:
-        return self.expand_rect_with_padding(
-            (0, 0, *self._get_text_rect_required_size())
-        ).size
-
-    def get_text(self) -> str:
-        return self.text
-
-    def _render_font(self, params: dict) -> pygame.Surface:
-
-        if self.draw_mode == bf.drawMode.SOLID:
-            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()
-            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_ascent() - self.font_object.get_descent()
-        if not self.text:
-            size = (0,font_height)
-        else:
-            tmp_text = self.text
-            if self.text.endswith('\n'):
-                tmp_text+=" "
-            params = {
-                "font_name": self.font_object.name,
-                "text": tmp_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_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) -> bool:
-        ret = False
-        target_size = self.resolve_size(self.get_min_required_size())
+    def get_text(self)->str:
+        return self._text
 
-        if self.rect.size != target_size :
-            self.set_size(target_size)
-            ret = True
-            # self.apply_post_updates(skip_draw=True)
-            # return True
 
-        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)
-        return ret
-
-    def _paint_text(self) -> None:
-        if self.font_object is None:
-            print(f"No font for widget with text : '{self}' :(")
+    def _build_text(self)-> None:
+        if self._font_object is None:
+            print("No font :(")
             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, 
-            "wraplength": wrap,
-        }
-
-        self.text_surface = self._render_font(params)
-        if self.show_text_outline:
-            self.text_outline_surface = (
-                pygame.mask.from_surface(self.text_surface)
-                .convolve(self._text_outline_mask)
-                .to_surface(setcolor=self.text_outline_color, unsetcolor=(0, 0, 0, 0))
-            )
-
-            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_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
-    ):
-        if alignment == bf.alignment.LEFT:
-            alignment = bf.alignment.MIDLEFT
-        elif alignment == bf.alignment.MIDRIGHT:
-            alignment = bf.alignment.MIDRIGHT
-
-        pos = area.__getattribute__(alignment.value)
-        text_rect.__setattr__(alignment.value, pos)
-        text_rect.y = ceil(text_rect.y)
-
-    def build(self) -> bool:
-        """
-        return True if size changed
-        """
-        
-        size_changed = self._build_layout()
+        # render(text, antialias, color, bgcolor=None, wraplength=0) -> Surface
+        self._text_surface = self._font_object.render(
+            text        = self._text,
+            antialias   = self._antialias,
+            color       = self._text_color,
+            bgcolor     = self._color,
+            wraplength  = 0
+        )
+        self._text_rect = self._text_surface.get_frect()
+
+    def _build_layout(self)->None:
+        if self.autoresize:
+            if self.rect.size != self.inflate_rect_by_padding(self._text_rect).size :
+                self.set_size(
+                    self._text_rect.w + self.padding[0]+self.padding[2], 
+                    self._text_rect.h + self.padding[1]+self.padding[3] 
+                )
+                return
+        self._text_rect.center = self.get_content_rect_rel().center
+        self.surface.blit(self._text_surface,self._text_rect)
+                
+    def build(self)->None:
         super().build()
-        return size_changed
-        
-        
-    def paint(self) -> None:
-        super().paint()
-        if self.font_object:
-            self._paint_text()
+        if not self._font_object:return
+        self._build_text()
+        self._build_layout()
+