batframework 1.0.8a2__py3-none-any.whl → 1.0.8a4__py3-none-any.whl

batFramework/gui/indicator.py

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

batFramework/gui/interactiveWidget.py

@@ -1,22 +1,186 @@
 from .widget import Widget
+from typing import Self
+from typing import TYPE_CHECKING
+import pygame
+from math import cos
+
+if TYPE_CHECKING:
+    from .container import Container
+import batFramework as bf
+
 
 class InteractiveWidget(Widget):
-    def __init__(self,*args,**kwargs):
-        super().__init__(convert_alpha = True)
+    def __init__(self, *args, **kwargs) -> None:
+        self.is_focused: bool = False
+        self.is_hovered: bool = False
+        self.is_clicked_down: bool = False
+        self.focused_index = 0
         self.focusable = True
-        self.is_focused : bool = False
+        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
+
+    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 on_get_focus(self)->None:
+    def on_get_focus(self) -> None:
         self.is_focused = True
+        self.do_on_get_focus()
 
-    def on_lose_focus(self)->None:
+    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)
-            
+        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:
+            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:
+            self.parent.focus_prev_tab(self)
+
+    def focus_next_sibling(self) -> None:
+        if isinstance(self.parent, bf.Container):
+            self.parent.focus_next_child()
+
+    def focus_prev_sibling(self) -> None:
+        if isinstance(self.parent, bf.Container):
+            self.parent.focus_prev_child()
+
+    def on_key_down(self, key) -> bool:
+        if key == pygame.K_DOWN:
+            self.focus_next_sibling()
+        elif key == pygame.K_UP:
+            self.focus_prev_sibling()
+        elif key == pygame.K_TAB and self.parent:
+            keys = pygame.key.get_pressed()
+            if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
+
+                self.focus_prev_tab(self)
+            else:
+                self.focus_next_tab(self)
+
+        else:
+
+            return self.do_on_key_down(key)
+
+        return False
+
+    def on_key_up(self, key) -> bool:
+        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 on_click_down(self, button: int) -> bool:
+        self.is_clicked_down = True
+        return self.do_on_click_down(button)
+
+    def on_click_up(self, button: int) -> bool:
+        self.is_clicked_down = False
+        return self.do_on_click_up(button)
+
+    def do_on_click_down(self, button: int) -> bool:
+        return False
+
+    def do_on_click_up(self, button: int) -> bool:
+        return False
+
+    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
+        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:
+        delta = 4 + ((2 * cos(pygame.time.get_ticks() / 100)) // 2) * 2
+        pygame.draw.rect(
+            camera.surface,
+            "white",
+            self.rect.move(-camera.rect.x, -camera.rect.y),#.inflate(delta, delta),
+            1,
+        )

batFramework/gui/label.py

@@ -3,108 +3,326 @@ import pygame
 from .shape import Shape
 from typing import Self
 
+
 class Label(Shape):
-    def __init__(self,text:str) -> None:   
-        self._text = ""
+    _text_cache = {}
+
+    def __init__(self, text: str = "") -> None:
+        self.text = text
+
+        self.resized_flag: bool = False
+
         # Enable/Disable antialiasing
-        self._antialias : bool = True
-        
-        self._text_size = bf.const.DEFAULT_TEXT_SIZE
-        
-        self._text_color : tuple[int,int,int]|str = "black"
+        self.antialias: bool = bf.FontManager().DEFAULT_ANTIALIAS
+
+        self.text_size = bf.FontManager().DEFAULT_TEXT_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)
+
         # 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 = None
+        self.text_rect = pygame.FRect(0, 0, 0, 0)
         # 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.text_surface: pygame.Surface = pygame.Surface((0, 0))
+        self.do_caching: bool = False
+
+        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.set_debug_color("blue")
-        self.set_color("white")
+        self.set_color("gray50")
         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()
+    @staticmethod
+    def clear_cache():
+        Label._text_cache = {}
+
+    def __str__(self) -> str:
+        return f"Label({self.text})"
+
+    def enable_caching(self) -> Self:
+        self.do_caching = True
         return self
 
-    def to_string_id(self)->str:
-        return f"Label({self._text})"
+    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
+        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_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 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()
+    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
         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()
+    def set_underlined(self, value: bool) -> Self:
+        if value == self.is_underlined:
+            return self
+        self.is_underlined = value
+        self.dirty_surface = True
         return self
 
-    def get_text_size(self)-> int:
-        return self._text_size
+    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)
 
-    def is_antialias(self)->bool:
-        return self._antialias
+    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_surface = True
+        return self
 
-    def set_antialias(self,value:bool)->"Label":
-        self._antialias = value
-        self.build()
+    def set_text_outline_color(self, color) -> Self:
+        self.text_outline_color = color
+        self.dirty_surface = True
         return self
 
-    def set_text(self,text:str) -> "Label":
-        if text == self._text : return self
-        self._text = text
-        self.build()
+    def enable_text_outline(self) -> Self:
+        self.show_text_outline = True
+        self.dirty_surface = True
         return self
-    
-    def get_text(self)->str:
-        return self._text
 
+    def disable_text_outline(self) -> Self:
+        self.show_text_outline = False
+        self.dirty_surface = True
+        return self
 
-    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
+    def set_alignment(self, alignment: bf.alignment) -> Self:
+        self.alignment = alignment
+        self.dirty_surface = True
+        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
+        return self
+
+    def get_debug_outlines(self):
+        if self.visible:
+            yield (self.text_rect.move(*self.rect.topleft), "purple")
+        yield from super().get_debug_outlines()
+
+    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 = round(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
+        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]:
+        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
+        return res[0] if self.autoresize_w else self.rect.w, (
+            res[1] if self.autoresize_h else self.rect.h
         )
-        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] 
-                )
+
+    def get_text(self) -> str:
+        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
+        else:
+            params.pop("font_name")
+            surf = self.font_object.render(**params)
+
+        return surf
+    def _get_text_rect_required_size(self):
+        params = {
+            "font_name": self.font_object.name,
+            "text": self.text,
+            "antialias": False,
+            "color": "white",
+            "bgcolor": "black",  # 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 else 0,
+        }
+
+        size = self._render_font(params).get_size()
+        s = self._text_outline_mask.get_size()
+        return size[0] + s[0]//2, size[1] + s[1]//2
+    def _build_layout(self) -> None:
+
+        self.text_rect.size = self._get_text_rect_required_size()
+        
+        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:
+                self.set_size(target_rect.size)
+                self.build()
                 return
-        self._text_rect.center = self.get_content_rect_rel().center
-        self.surface.blit(self._text_surface,self._text_rect)
-                
-    def build(self)->None:
+        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
+        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
+
+    def _paint_text(self) -> None:
+        if self.font_object is None:
+            print(f"No font for widget with text : '{self}' :(")
+            return
+
+        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 else 0,
+        }
+        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))
+            )
+
+        l = []
+        outline_offset = self._get_outline_offset()
+        if self.show_text_outline:
+            l.append(
+                (
+                    self.text_outline_surface,
+                    self.text_rect.move(0, self.relief - self.get_relief()),
+                )
+            )
+        l.append(
+            (self.text_surface, self.text_rect.move(outline_offset[0], self.relief - self.get_relief() + outline_offset[1]))
+        )
+        self.surface.fblits(l)
+
+    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)
+
+    def build(self) -> None:
         super().build()
-        if not self._font_object:return
-        self._build_text()
         self._build_layout()
 
+    def paint(self) -> None:
+        super().paint()
+        if self.font_object:
+            self._paint_text()