batframework 1.0.10__py3-none-any.whl → 2.0.0__py3-none-any.whl

batFramework/gui/indicator.py

@@ -1,40 +1,116 @@
-from .shape import Shape
-from typing import Any
-import pygame
-# from .constraints import ConstraintAspectRatio
-
-class Indicator(Shape):
-    def __init__(self,width:int|float= 10,height:int|float=10)->None:
-        super().__init__(width,height)
-
-    def to_string_id(self)->str:
-        return "Indicator"
-
-    def set_value(self,value:Any)->None:
-        pass
-
-    def get_value(self)->Any:
-        pass
-
-    def _build_indicator(self)->None:
-        pass
-    
-    def build(self)->None:
-        super().build()
-        self._build_indicator()
-
-
-class ToggleIndicator(Indicator):
-    def __init__(self,default_value:bool)->None:
-        self.value:bool = default_value
-        super().__init__(20,20)
-        # self.add_constraint(ConstraintAspectRatio(1))
-
-    def set_value(self,value)->None:
-        self.value = value
-        self.set_color("green" if value else "red")
-        self.build()
-
-    def get_value(self)->bool:
-        return self.value
-# 
+from .shape import Shape
+from typing import Any, Self, Callable
+import pygame
+from .widget import Widget
+from .interactiveWidget import InteractiveWidget
+from .draggableWidget import DraggableWidget
+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"
+        self.set_outline_width(1)
+        self.set_outline_color("black")
+
+    def to_string_id(self) -> str:
+        return "Indicator"
+
+    def set_value(self, value: Any) -> None:
+        pass
+
+    def get_value(self) -> Any:
+        pass
+
+    def top_at(self, x, y):
+        return None
+
+
+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")
+        self.set_value(default_value)
+        self.callback(default_value)
+        # TODO aspect ratio would be good right about here
+        self.add_constraints(bf.gui.AspectRatio(1,reference_axis=bf.axis.VERTICAL))
+
+    def __str__(self):
+        return "ToggleIndicator"
+
+    def set_callback(self, callback : Callable[[bool],Any]) -> Self:
+        self.callback = callback
+        return self
+
+    def set_value(self, value: bool) -> None:
+        self.value = value
+        if self.callback:
+            self.callback(value)
+        self.dirty_surface = True
+
+    def get_value(self) -> bool:
+        return self.value
+
+    def top_at(self, x: float, y: float) -> "None|Widget":
+        r = super().top_at(x, y)
+        if r is self:
+            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
+
+        )
+        
+
+

batFramework/gui/interactiveWidget.py

@@ -1,22 +1,243 @@
-from .widget import Widget
-
-class InteractiveWidget(Widget):
-    def __init__(self,*args,**kwargs):
-        super().__init__(convert_alpha = True)
-        self.focusable = True
-        self.is_focused : bool = False
-
-    def get_focus(self)->bool:
-        if self.parent is None or not self.focusable: return False
-        self.get_root().focus_on(self)
-
-    def on_get_focus(self)->None:
-        self.is_focused = True
-
-    def on_lose_focus(self)->None:
-        self.is_focused = False
-        
-    def lose_focus(self)->bool:
-        if self.is_focused and self.parent is not None:
-            self.get_root().focus_on(None)
-            
+from .widget import Widget
+from typing import Self
+import pygame
+from math import cos
+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
+        self.click_pass_through : bool = False
+        super().__init__(*args, **kwargs)
+
+
+    def handle_event(self, event):
+        if self.is_hovered:
+            if event.type == pygame.MOUSEBUTTONDOWN:
+                self.is_clicked_down[event.button-1] = True
+                self.on_click_down(event.button,event)
+            elif event.type == pygame.MOUSEBUTTONUP:
+                self.is_clicked_down[event.button-1] = False
+                self.on_click_up(event.button,event)
+
+        if self.is_focused:
+            if event.type == pygame.KEYDOWN:
+                self.on_key_down(event.key,event)
+            elif event.type == pygame.KEYUP:
+                self.on_key_up(event.key,event)
+
+    def set_click_pass_through(self,pass_through:bool)->Self:
+        """
+        # Allows mouse click events to pass through this widget to underlying widgets if True.
+        """
+        self.click_pass_through = pass_through
+        return self
+
+
+    def allow_focus_to_self(self) -> bool:
+        return self.visible
+
+    def get_focus(self) -> bool:
+        if self.allow_focus_to_self() and ((r := self.get_root()) is not None):
+            r.focus_on(self)
+            return True
+        return False
+
+    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 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
+
+        if hasattr(current.parent, "layout"):
+            siblings =  current.parent.get_interactive_children()
+        else:
+            siblings = current.parent.children 
+
+        start_index = siblings.index(current)
+        good_index = -1
+        for i in range(start_index + 1, len(siblings)):
+            sibling = siblings[i]
+            if isinstance(sibling,InteractiveWidget) and  not(sibling is current) :
+                if sibling.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()]
+        if hasattr(current.parent, "layout"):
+            siblings =  current.parent.get_interactive_children()
+        else:
+            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) and  not(sibling is current) :
+                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,event) -> None:
+        self.do_on_key_down(key,event)
+
+    def on_key_up(self, key,event) -> None:
+        self.do_on_key_up(key,event)
+
+    def on_click_down(self, button: int,event=None) -> None:
+        if not self.click_pass_through:
+            event.consumed = True
+        self.do_on_click_down(button,event)
+
+    def on_click_up(self, button: int,event=None) -> None:
+        if not self.click_pass_through:
+            event.consumed = True
+        self.do_on_click_up(button,event)
+
+    def on_get_focus(self) -> None:
+        self.is_focused = True
+        if isinstance(self.parent,bf.gui.InteractiveWidget):
+            self.parent.set_focused_child(self)
+        self.do_on_get_focus()
+
+    def on_lose_focus(self) -> None:
+        self.is_focused = False
+        self.do_on_lose_focus()
+
+    def do_on_get_focus(self) -> None:
+        pass
+
+    def do_on_lose_focus(self) -> None:
+        pass
+
+    def do_on_key_down(self, key,event) -> None:
+        return
+
+    def do_on_key_up(self, key,event) -> None:
+        return
+
+    def do_on_click_down(self, button: int,event=None) -> None:
+        return 
+
+    def do_on_click_up(self, button: int,event=None) -> 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:
+        if isinstance(self,bf.gui.Shape):
+            prop = 8
+            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+self.outline_width, prop+self.outline_width))
+
+            # 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)
+

batFramework/gui/label.py

@@ -1,110 +1,147 @@
-import batFramework as bf
-import pygame
-from .shape import Shape
-from typing import Self
-
-class Label(Shape):
-    def __init__(self,text:str) -> None:   
-        self._text = ""
-        # Enable/Disable antialiasing
-        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
-        # reference to the font object
-        self._font_object = None
-        # Rect containing the text of the label
-        self._text_rect = None
-        # text surface (result of font.render)
-        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("white")
-        self.set_autoresize(True)
-        self.set_font(force=True)
-        self.set_text(text)
-
-    def set_text_color(self,color)->Self:
-        self._text_color = color
-        self.build()
-        return self
-
-    def to_string_id(self)->str:
-        return f"Label({self._text})"
-
-
-    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_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_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 get_text_size(self)-> int:
-        return self._text_size
-
-    def is_antialias(self)->bool:
-        return self._antialias
-
-    def set_antialias(self,value:bool)->"Label":
-        self._antialias = value
-        self.build()
-        return self
-
-    def set_text(self,text:str) -> "Label":
-        if text == self._text : return self
-        self._text = text
-        self.build()
-        return self
-    
-    def get_text(self)->str:
-        return self._text
-
-
-    def _build_text(self)-> None:
-        if self._font_object is None:
-            print("No font :(")
-            return
-        # 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()
-        if not self._font_object:return
-        self._build_text()
-        self._build_layout()
-
+import batFramework as bf
+import pygame
+from .shape import Shape
+from .textWidget import TextWidget
+from typing import Literal, Self,Union
+from math import ceil
+
+class Label(Shape):
+
+    def __init__(self, text: str = "") -> None:
+        super().__init__((0, 0))
+        self.alignment: bf.alignment = bf.alignment.CENTER
+        self.text_widget = TextWidget(text)
+        self.set_padding((10, 4))
+        self.set_debug_color("blue")
+        self.set_color("gray50")
+        self.set_autoresize(True)
+        self.set_font(force=True)
+        self.add(self.text_widget)
+        
+    def __str__(self) -> str:
+        return f"Label({repr(self.text_widget.text)})"
+
+    def set_visible(self, value):
+        self.text_widget.set_visible(value)
+        return super().set_visible(value)
+
+    def set_allow_scroll(self, value:bool)->Self:
+        self.text_widget.set_allow_scroll(value)
+        return self
+
+    def set_text_color(self, color) -> Self:
+        self.text_widget.set_text_color(color)
+        return self
+
+    def set_line_alignment(self, alignment: int) -> Self:
+        """
+        alignment: One of pygame.FONT_CENTER, pygame.FONT_LEFT, pygame.FONT_RIGHT
+        """
+        self.text_widget.set_line_alignment(alignment)
+        return self
+
+    def set_italic(self, value: bool) -> Self:
+        self.text_widget.set_italic(value)
+        return self
+
+    def set_bold(self, value: bool) -> Self:
+        self.text_widget.set_bold(value)
+        return self
+
+    def set_underlined(self, value: bool) -> Self:
+        self.text_widget.set_underlined(value)
+        return self
+
+    def set_text_outline_mask_size(self,size:tuple[int,int])->Self:
+        self.text_widget.set_text_outline_mask_size(size)
+        return self
+
+    def set_text_outline_matrix(self, matrix: list[list[0 | 1]]) -> Self:
+        self.text_widget.set_text_outline_matrix(matrix)
+        return self
+
+    def set_text_outline_color(self, color) -> Self:
+        self.text_widget.set_text_outline_color(color)
+        return self
+
+    def set_text_bg_color(self, color) -> Self:
+        self.text_widget.set_text_bg_color(color)
+        return self
+
+    def set_show_text_outline(self,value:bool) -> Self:
+        self.text_widget.set_show_text_outline(value)
+        return self
+
+    def set_alignment(self, alignment: bf.alignment) -> Self:
+        self.alignment = alignment
+        self.dirty_shape = True
+        return self
+
+    def set_auto_wraplength(self, val: bool) -> Self:
+        self.text_widget.set_auto_wraplength(val)
+        return self
+
+    def get_debug_outlines(self):
+        if self.visible:
+            yield from super().get_debug_outlines()
+            yield from self.text_widget.get_debug_outlines()
+
+    def set_font(self, font_name: str = None, force: bool = False) -> Self:
+        self.text_widget.set_font(font_name,force)
+        return self
+
+    def set_text_size(self, text_size: int) -> Self:
+        self.text_widget.set_text_size(text_size)
+        return self
+
+    def get_text_size(self) -> int:
+        return self.text_widget.text_size
+
+    def is_antialias(self) -> bool:
+        return self.text_widget.antialias
+
+    def set_antialias(self, value: bool) -> Self:
+        self.text_widget.set_antialias(value)
+        return self
+
+    def set_text(self, text: str) -> Self:
+        self.text_widget.set_text(text)
+        return self
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        return self.expand_rect_with_padding(
+            (0, 0, *self.text_widget.get_min_required_size())
+        ).size
+
+    def get_text(self) -> str:
+        return self.text_widget.text
+
+    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):
+        ret = False
+        target_size = self.resolve_size(self.get_min_required_size())
+        if self.rect.size != target_size :
+            self.set_size(target_size)
+            self.text_widget.set_size(self.get_inner_rect().size)
+            ret = True
+
+        padded = self.get_inner_rect()
+        self.align_text(self.text_widget.rect, padded, self.alignment)
+        return ret
+    
+    def apply_pre_updates(self):
+        if self.text_widget.dirty_shape:
+            self.dirty_shape =True
+        return super().apply_pre_updates()
+