batframework 1.0.8a1__py3-none-any.whl → 1.0.8a3__py3-none-any.whl

batFramework/gui/layout.py

@@ -1,12 +1,13 @@
 import batFramework as bf
 from .widget import Widget
 from .constraints.constraints import *
-from typing import Self,TYPE_CHECKING
+from typing import Self, TYPE_CHECKING
 import pygame
 
 if TYPE_CHECKING:
     from .container import Container
 
+
 class Layout:
     def __init__(self, parent: "Container" = None):
         self.parent = parent
@@ -23,46 +24,58 @@ class Layout:
         self.notify_parent()
 
     def notify_parent(self) -> None:
-        if self.parent:self.parent.dirty_children = True
+        if self.parent:
+            self.parent.dirty_children = True
 
     def arrange(self) -> None:
         return
 
-    def clamp_scroll(self)->None:
-        return
-
-    def get_raw_size(self)->tuple[float,float]:
-        return self.parent.rect.size if self.parent else 0,0
+    def get_raw_size(self) -> tuple[float, float]:
+        """
+        Returns the supposed size the container should have to encapsulate perfectly all of its widgets
+        """
+        return self.parent.rect.size if self.parent else (0, 0)
 
-    def get_auto_size(self)->tuple[float,float]:
-        return self.parent.rect.size if self.parent else 0,0
+    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)
+        """
+        target_size = list(self.get_raw_size())
+        if not self.parent.autoresize_w:
+            target_size[0] = self.parent.rect.w
+        if not self.parent.autoresize_h:
+            target_size[1] = self.parent.rect.h
+        return target_size
 
-    def focus_next_child(self)->None:
+    def focus_next_child(self) -> None:
         l = self.parent.get_interactive_children()
         self.parent.focused_index = min(self.parent.focused_index + 1, len(l) - 1)
         focused = l[self.parent.focused_index]
         focused.get_focus()
         self.scroll_to_widget(focused)
 
-    def focus_prev_child(self)->None:
+    def focus_prev_child(self) -> None:
         l = self.parent.get_interactive_children()
         self.parent.focused_index = max(self.parent.focused_index - 1, 0)
         focused = l[self.parent.focused_index]
         focused.get_focus()
         self.scroll_to_widget(focused)
 
-    def scroll_to_widget(self,widget:Widget)->None:
+    def scroll_to_widget(self, widget: Widget) -> None:
         padded = self.parent.get_padded_rect()
         r = widget.rect
-        if padded.contains(r):return
+        if padded.contains(r):
+            return
         clamped = r.clamp(padded)
-        dx,dy = clamped.move(-r.x,-r.y).topleft
-        self.parent.scroll_by((-dx,-dy))
+        dx, dy = clamped.move(-r.x, -r.y).topleft
+        self.parent.scroll_by((-dx, -dy))
 
+    def handle_event(self, event):
+        pass
 
 
 class Column(Layout):
-    def __init__(self, gap: int = 0,spacing:bf.spacing = bf.spacing.MANUAL):
+    def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
         super().__init__()
         self.gap = gap
         self.spacing = spacing
@@ -71,50 +84,81 @@ class Column(Layout):
         self.gap = value
         self.notify_parent()
         return self
-    
-    def set_spacing(self,spacing: bf.spacing)->Self:
+
+    def set_spacing(self, spacing: bf.spacing) -> Self:
         self.spacing = spacing
         self.notify_parent()
         return self
 
-    def get_raw_size(self)-> tuple[float,float]:
+    def get_raw_size(self) -> tuple[float, float]:
         len_children = len(self.parent.children)
-        if not len_children : return self.parent.rect.size 
+        if not len_children:
+            return self.parent.rect.size
         parent_height = sum(c.get_min_required_size()[1] for c in self.parent.children)
         parent_width = max(c.get_min_required_size()[0] for c in self.parent.children)
         if self.gap:
             parent_height += (len_children - 1) * self.gap
-        target_rect = self.parent.inflate_rect_by_padding((0,0,parent_width,parent_height))
+        target_rect = self.parent.inflate_rect_by_padding(
+            (0, 0, parent_width, parent_height)
+        )
         return target_rect.size
-    
-    def get_auto_size(self)-> tuple[float,float]:
+
+    def get_auto_size(self) -> tuple[float, float]:
         target_size = list(self.get_raw_size())
-        if not self.parent.autoresize_w : target_size[0] = self.parent.rect.w
-        if not self.parent.autoresize_h : target_size[1] = self.parent.rect.h
+        if not self.parent.autoresize_w:
+            target_size[0] = self.parent.rect.w
+        if not self.parent.autoresize_h:
+            target_size[1] = self.parent.rect.h
         return target_size
 
     def arrange(self) -> None:
         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.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))
+            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)
+        self.child_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
         y = self.child_rect.top
-        for child in self.parent.children :
-            child.set_position(self.child_rect.x,y)
-            y+= child.get_min_required_size()[1] + self.gap
+        for child in self.parent.children:
+            child.set_position(self.child_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:
+            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
+                event.consumed = True
+                self.parent.clamp_scroll()
+
 
 class Row(Layout):
-    def __init__(self, gap: int = 0,spacing: bf.spacing=bf.spacing.MANUAL):
+    def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
         super().__init__()
         self.gap = gap
         self.spacing = spacing
@@ -123,35 +167,40 @@ class Row(Layout):
         self.gap = value
         self.notify_parent()
         return self
-    
-    def set_spacing(self,spacing: bf.spacing)->Self:
+
+    def set_spacing(self, spacing: bf.spacing) -> Self:
         self.spacing = spacing
         self.notify_parent()
         return self
 
-
     def get_raw_size(self) -> tuple[float, float]:
         len_children = len(self.parent.children)
-        if not len_children: return self.parent.rect.size
+        if not len_children:
+            return self.parent.rect.size
         parent_width = sum(c.get_min_required_size()[0] for c in self.parent.children)
         parent_height = max(c.get_min_required_size()[1] for c in self.parent.children)
         if self.gap:
             parent_width += (len_children - 1) * self.gap
-        target_rect = self.parent.inflate_rect_by_padding((0, 0, parent_width, parent_height))
+        target_rect = self.parent.inflate_rect_by_padding(
+            (0, 0, parent_width, parent_height)
+        )
 
         return target_rect.size
 
     def get_auto_size(self) -> tuple[float, float]:
         target_size = list(self.get_raw_size())
-        if not self.parent.autoresize_w: target_size[0] = self.parent.rect.w
-        if not self.parent.autoresize_h: target_size[1] = self.parent.rect.h
+        if not self.parent.autoresize_w:
+            target_size[0] = self.parent.rect.w
+        if not self.parent.autoresize_h:
+            target_size[1] = self.parent.rect.h
         return target_size
 
     def arrange(self) -> None:
         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)
+            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:
@@ -166,3 +215,26 @@ class Row(Layout):
         for child in self.parent.children:
             child.set_position(x, self.child_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:
+            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((-10, 0))
+                elif event.button == 5:
+                    self.parent.scroll_by((10, 0))
+                else:
+                    return
+                event.consumed = True
+                self.parent.clamp_scroll()

batFramework/gui/meter.py

@@ -10,14 +10,9 @@ def custom_top_at(self, x, y):
 
 
 class Meter(Shape):
-    def __init__(
-        self,
-        min_value: float = 0,
-        max_value: float = 1,
-        step: float = 0.1
-    ):
+    def __init__(self, min_value: float = 0, max_value: float = 1, step: float = 0.1):
         super().__init__()
-        self.min_value, self.max_value = min_value,max_value
+        self.min_value, self.max_value = min_value, max_value
         self.step = step
         self.snap: bool = False
         self.value = self.max_value
@@ -67,7 +62,7 @@ class Meter(Shape):
         return self.value / (self.max_value - self.min_value)
 
     def _build_content(self) -> None:
-        width = (self.get_padded_width() * self.get_ratio())
+        width = self.get_padded_width() * self.get_ratio()
         self.content.set_size((width, self.get_padded_height()))
         self.content.set_position(*self.get_padded_rect().topleft)
 

batFramework/gui/radioButton.py

@@ -1,62 +1,84 @@
 import batFramework as bf
-from typing import Self,Any,Callable
+from typing import Self, Any, Callable
 from .toggle import Toggle
 
-class RadioVariable:...
+
+class RadioVariable: ...
+
 
 class RadioButton(Toggle):
-    def __init__(self, text: str, radio_value:Any = None) -> None:
-        super().__init__(text,None, False)
-        self.radio_value : Any = radio_value if radio_value is not None else text if text else None
-        self.radio_variable : RadioVariable = None
+    def __init__(self, text: str, radio_value: Any = None) -> None:
+        super().__init__(text, None, False)
+        self.radio_value: Any = (
+            radio_value if radio_value is not None else text if text else None
+        )
+        self.radio_variable: RadioVariable = None
+
+    def __str__(self) -> str:
+        return (
+            f"RadioButton({self.radio_value}|{'Active' if self.value else 'Inactive'})"
+        )
 
-    def set_radio_value(self,value:Any)->Self:
+    def set_radio_value(self, value: Any) -> Self:
         self.radio_value = value
-        self.update_radio()
+
+        if self.radio_variable:
+            self.radio_variable.update_buttons()
         return self
-    
+
     def set_text(self, text: str) -> Self:
         flag = False
-        if self.value == self.text or self.value is None: flag = True
+        if self.value == self.text or self.value is None:
+            flag = True
         super().set_text(text)
         if flag:
             self.set_radio_value(self.text)
         return self
 
     def click(self) -> None:
-        if self.radio_variable is None: return
+        if self.radio_variable is None:
+            return
         self.radio_variable.set_value(self.radio_value)
 
+
 class RadioVariable:
-    def __init__(self)->None:
-        self.buttons : list[RadioButton] = []
+    def __init__(self) -> None:
+        self.buttons: list[RadioButton] = []
         self.value = None
-        self.modify_callback : Callable[[Any],] = None
+        self.modify_callback: Callable[[Any],] = None
+
+    def set_modify_callback(self, callback) -> Self:
+        self.modify_callback = callback
+        return self
 
-    def link(self,*buttons:RadioButton)->Self:
-        if not buttons : return self
-        for b in buttons : 
+    def link(self, *buttons: RadioButton) -> Self:
+        if not buttons:
+            return self
+        for b in buttons:
             b.radio_variable = self
         self.buttons.extend(buttons)
-        
+
         if self.value is None:
             self.set_value(buttons[0].radio_value)
         else:
-            self.update_buttons() 
+            self.update_buttons()
         return self
 
-    def unlink(self,*buttons)->Self:
+    def unlink(self, *buttons) -> Self:
         for b in self.buttons:
             if b in buttons:
                 b.radio_variable = None
         self.buttons = [b for b in self.buttons if b not in buttons]
         return self
 
-    def set_value(self,value:Any):
-        if value == self.value: return
+    def set_value(self, value: Any) -> Self:
+        if value == self.value:
+            return
         self.value = value
-        if self.modify_callback :self.modify_callback(value)
-        self.update_buttons() 
+        if self.modify_callback:
+            self.modify_callback(value)
+        self.update_buttons()
+        return self
 
     def update_buttons(self):
-        _ = [b.set_value(b.radio_value == self.value,False) for b in self.buttons]
+        _ = [b.set_value(b.radio_value == self.value, False) for b in self.buttons]

batFramework/gui/root.py

@@ -2,6 +2,8 @@ import batFramework as bf
 from .interactiveWidget import InteractiveWidget
 from .widget import Widget
 import pygame
+from typing import Self
+import sys
 
 
 class Root(InteractiveWidget):
@@ -14,12 +16,16 @@ class Root(InteractiveWidget):
         self.focused: InteractiveWidget | None = self
         self.hovered: Widget | None = self
         self.set_debug_color("yellow")
-        self.set_render_order(999)
+        self.set_render_order(sys.maxsize)
         self.clip_children = False
 
     def __str__(self) -> str:
         return "Root"
 
+    def set_parent_scene(self, parent_scene: bf.Scene) -> Self:
+        bf.StyleManager().register_widget(self)
+        return super().set_parent_scene(parent_scene)
+
     def get_focused(self) -> Widget | None:
         return self.focused
 
@@ -34,8 +40,14 @@ class Root(InteractiveWidget):
             self.hovered.on_exit()
         self.hovered = None
 
+    def get_debug_outlines(self):
+        yield (self.rect, self.debug_color)
+        for child in self.children:
+            yield from child.get_debug_outlines()
+
     def focus_on(self, widget: InteractiveWidget | None) -> None:
-        if widget == self.focused : return
+        if widget == self.focused:
+            return
         if widget and not widget.allow_focus_to_self():
             return
         if self.focused is not None:
@@ -46,26 +58,34 @@ class Root(InteractiveWidget):
         self.focused = widget
         self.focused.on_get_focus()
 
-    def get_by_tags(self,*tags)->list[Widget]:
+    def get_by_tags(self, *tags) -> list[Widget]:
         res = []
-        def getter(w:Widget):
+
+        def getter(w: Widget):
             nonlocal res
             if any(t in w.tags for t in tags):
                 res.append(w)
+
         self.visit(getter)
         return res
 
-    def get_by_uid(self,uid:int)->Widget:
-        def helper(w: Widget,uid):
+    def focus_next_tab(self, widget):
+        return True
+
+    def focus_prev_tab(self, widget):
+        return True
+
+    def get_by_uid(self, uid: int) -> "Widget":
+        def helper(w: "Widget", uid: int) -> "Widget":
             if w.uid == uid:
                 return w
             for child in w.children:
-                res = helper(child,uid)
-                if res : 
-                    return child
-                
+                res = helper(child, uid)
+                if res is not None:
+                    return res
             return None
-        return helper(self,uid)
+
+        return helper(self, uid)
 
     def set_size(self, size: tuple[float, float], force: bool = False) -> "Root":
         if not force:
@@ -74,23 +94,25 @@ class Root(InteractiveWidget):
         # self.build(resolve_constraints=True)
         return self
 
-
     def do_handle_event(self, event):
-        # if event.type == pygame.VIDEORESIZE:
-        #     self.set_size(event.w, event.h, force=True)
-        #     return True
         if self.focused:
             if event.type == pygame.KEYDOWN:
-                self.focused.on_key_down(event.key)
-            if event.type == pygame.KEYUP:
-                self.focused.on_key_up(event.key)
-        elif not self.hovered or not isinstance(self.hovered, InteractiveWidget):
+                if self.focused.on_key_down(event.key):
+                    event.consumed = True
+            elif event.type == pygame.KEYUP:
+                if self.focused.on_key_up(event.key):
+                    event.consumed = True
+
+        if not self.hovered or (not isinstance(self.hovered, InteractiveWidget)):
             return
+
         if event.type == pygame.MOUSEBUTTONDOWN:
-            self.hovered.on_click_down(event.button)
-        elif event.type == pygame.MOUSEBUTTONUP:
-            self.hovered.on_click_up(event.button)
+            if self.hovered.on_click_down(event.button):
+                event.consumed = True
 
+        elif event.type == pygame.MOUSEBUTTONUP:
+            if self.hovered.on_click_up(event.button):
+                event.consumed = True
 
     def do_on_click_down(self, button: int) -> None:
         if button == 1:
@@ -119,7 +141,10 @@ class Root(InteractiveWidget):
 
     def draw(self, camera: bf.Camera) -> int:
         super().draw(camera)
-        if self.focused and self.focused!=self:
+        if (
+            self.parent_scene
+            and self.parent_scene.active
+            and self.focused
+            and self.focused != self
+        ):
             self.focused.draw_focused(camera)
-
-

batFramework/gui/shape.py

@@ -1,13 +1,13 @@
 import batFramework as bf
 from .widget import Widget
 import pygame
-from typing import Self,Iterable
+from typing import Self, Iterable
 from math import ceil
 
 
 class Shape(Widget):
-    def __init__(self, size: tuple[float, float] = None,*args,**kwargs):
-        super().__init__(size=size,convert_alpha=True)
+    def __init__(self, size: tuple[float, float] = None, *args, **kwargs):
+        super().__init__(size=size, convert_alpha=True)
         self.color = (0, 0, 0, 0)
         self.border_radius: list[int] = [0]
         self.outline: int = 0
@@ -24,15 +24,15 @@ class Shape(Widget):
     def get_padded_height(self) -> float:
         return self.rect.h - self.padding[1] - self.padding[3] - self.relief
 
-    def get_padded_top(self)->float:
+    def get_padded_top(self) -> float:
         return self.rect.y + self.relief
 
-    def get_padded_rect(self)->pygame.FRect:
+    def get_padded_rect(self) -> pygame.FRect:
         return pygame.FRect(
             self.rect.x + self.padding[0],
             self.rect.y + self.padding[1],
             self.rect.w - self.padding[2] - self.padding[0],
-            self.rect.h - self.padding[1] - self.padding[3] - self.relief
+            self.rect.h - self.padding[1] - self.padding[3] - self.relief,
         )
 
     def set_shadow_color(self, color: tuple[int, int, int] | str) -> Self:
@@ -43,7 +43,8 @@ class Shape(Widget):
     def set_relief(self, relief: int) -> Self:
         if relief < 0:
             return self
-        if self.relief == relief : return self
+        if self.relief == relief:
+            return self
         self.relief = relief
         self.dirty_shape = True
         return self
@@ -100,7 +101,7 @@ class Shape(Widget):
         self.dirty_surface = True
         return self
 
-    def paint(self)->None:
+    def paint(self) -> None:
         if self.draw_mode == bf.drawMode.TEXTURED:
             self._paint_textured()
             return
@@ -113,8 +114,6 @@ class Shape(Widget):
             if self.outline:
                 self._paint_rounded_outline()
 
-
-
     def _paint_textured(self) -> None:
         self.surface.fill((0, 0, 0, 0))
         if self.texture_surface is None:
@@ -218,14 +217,10 @@ class Shape(Widget):
         self.surface.fblits(lst)
 
     def _get_elevated_rect(self) -> pygame.FRect:
-        return pygame.FRect(
-            0,0  , self.rect.w, self.rect.h - self.relief
-        )
+        return pygame.FRect(0, 0, self.rect.w, self.rect.h - self.relief)
 
     def _get_base_rect(self) -> pygame.FRect:
-        return pygame.FRect(
-            0, self.rect.h - self.relief , self.rect.w, self.relief
-        )
+        return pygame.FRect(0, self.rect.h - self.relief, self.rect.w, self.relief)
 
     def _paint_shape(self) -> None:
         self.surface.fill((0, 0, 0, 0))
@@ -237,8 +232,8 @@ class Shape(Widget):
         e = self._get_elevated_rect()
         b = e.copy()
         b.bottom = self.rect.h
-        pygame.draw.rect(self.surface, self.shadow_color,   b, 0, *self.border_radius)
-        pygame.draw.rect(self.surface, self.color,          e, 0, *self.border_radius)
+        pygame.draw.rect(self.surface, self.shadow_color, b, 0, *self.border_radius)
+        pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
 
     def _paint_outline(self) -> None:
         if self.relief:
@@ -269,7 +264,7 @@ class Shape(Widget):
         e = self._get_elevated_rect()
         b = e.copy()
         b.h += e.bottom - b.bottom
-        
+
         pygame.draw.rect(
             self.surface,
             self.outline_color,