batframework 1.0.7__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/gui/layout.py

@@ -1,96 +1,168 @@
 import batFramework as bf
 from .widget import Widget
-from .constraints import *
-from typing import Self
+from .constraints.constraints import *
+from typing import Self,TYPE_CHECKING
 import pygame
 
+if TYPE_CHECKING:
+    from .container import Container
 
 class Layout:
-    def __init__(self, parent: Widget = None):
+    def __init__(self, parent: "Container" = None):
         self.parent = parent
         self.child_constraints: list[Constraint] = []
         self.children_rect = pygame.FRect(0, 0, 0, 0)
 
     def set_child_constraints(self, *constraints) -> Self:
         self.child_constraints = list(constraints)
-        self.arrange()
+        self.notify_parent()
         return self
 
     def set_parent(self, parent: Widget):
         self.parent = parent
-        self.arrange()
+        self.notify_parent()
+
+    def notify_parent(self) -> None:
+        if self.parent:self.parent.dirty_children = True
 
     def arrange(self) -> None:
-        raise NotImplementedError("Subclasses must implement arrange  method")
+        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_auto_size(self)->tuple[float,float]:
+        return self.parent.rect.size if self.parent else 0,0
+
+    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:
+        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:
+        padded = self.parent.get_padded_rect()
+        r = widget.rect
+        if padded.contains(r):return
+        clamped = r.clamp(padded)
+        dx,dy = clamped.move(-r.x,-r.y).topleft
+        self.parent.scroll_by((-dx,-dy))
+
 
 
 class Column(Layout):
-    def __init__(self, gap: int = 0, fit_children: bool = True, center: bool = True):
+    def __init__(self, gap: int = 0,spacing:bf.spacing = bf.spacing.MANUAL):
         super().__init__()
         self.gap = gap
-        self.fit_children: bool = fit_children
-        self.center = center
+        self.spacing = spacing
 
-    def arrange(self) -> None:
-        if not self.parent or not self.parent.children:
-            return
+    def set_gap(self, value: float) -> Self:
+        self.gap = value
+        self.notify_parent()
+        return 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 
         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
-        self.children_rect.update(
-            self.parent.get_content_left(),
-            self.parent.get_content_top(),
-            parent_width,
-            parent_height,
-        )
-        if self.fit_children:
-            self.parent.set_size(parent_width,parent_height)
-        if self.center:
-            self.children_rect.center = self.parent.rect.center
-
-        current_y = self.children_rect.top
-
-        for child in self.parent.children:
-            child.set_position(self.parent.rect.x, current_y)
-            current_y += child.rect.h + self.gap
-            for c in self.child_constraints:
-                child.add_constraints(c)
+        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
+        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)
+        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))
+                self.parent.build()
+                self.arrange()
+                return
+        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
 
 class Row(Layout):
-    def __init__(self, gap: int = 0, fit_children: bool = True, center: bool = True):
+    def __init__(self, gap: int = 0,spacing: bf.spacing=bf.spacing.MANUAL):
         super().__init__()
         self.gap = gap
-        self.fit_children: bool = fit_children
-        self.center = center
+        self.spacing = spacing
 
-    def arrange(self) -> None:
-        if not self.parent or not self.parent.children:
-            return
+    def set_gap(self, value: float) -> Self:
+        self.gap = value
+        self.notify_parent()
+        return 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
         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
-        self.children_rect.update(
-            self.parent.get_content_left(),
-            self.parent.get_content_top(),
-            parent_width,
-            parent_height,
-        )
-        if self.center:
-            self.children_rect.center = self.parent.get_content_center()
-        if self.fit_children:
-            self.parent.set_size(parent_width,parent_height)
-            
-        current_x = self.children_rect.left
+        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
+        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)
+        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))
+                self.parent.build()
+                self.arrange()
+                return
+        self.child_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
+        x = self.child_rect.left
         for child in self.parent.children:
-            child.set_position(current_x, self.parent.rect.y)
-            current_x += child.rect.w + self.gap
-            for c in self.child_constraints:
-                child.add_constraints(c)
+            child.set_position(x, self.child_rect.y)
+            x += child.get_min_required_size()[0] + self.gap

batFramework/gui/meter.py

@@ -0,0 +1,76 @@
+import batFramework as bf
+from .shape import Shape
+from typing import Self
+
+
+def custom_top_at(self, x, y):
+    if Shape.top_at(self, x, y) == self:
+        return self.parent
+    return None
+
+
+class Meter(Shape):
+    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.step = step
+        self.snap: bool = False
+        self.value = self.max_value
+        self.content = Shape((0, 0)).set_color(bf.color.BLUE)
+        self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
+        self.add(self.content)
+        self.set_padding(1)
+        self.set_outline_width(1)
+        self.set_outline_color(bf.color.BLACK)
+        self.set_debug_color("pink")
+
+    def __str__(self) -> str:
+        return "Meter"
+
+    def set_step(self, step: float) -> Self:
+        self.step = step
+        self.set_value(self.value)
+        return self
+
+    def set_range(self, range_min: float, range_max: float) -> Self:
+        if range_min >= range_max:
+            print(
+                f"[Warning] : minimum value {range_min} is greater than or equal to maximum value {range_max}"
+            )
+            return self
+        self.min_value, self.max_value = range_min, range_max
+        self.dirty_shape = True
+
+    def get_debug_outlines(self):
+        yield from super().get_debug_outlines()
+        yield from self.content.get_debug_outlines()
+
+    def set_value(self, value: float) -> Self:
+        value = max(self.min_value, min(self.max_value, value))
+        value = round(value / self.step) * self.step
+        self.value = value
+        self.dirty_surface = True
+        return self
+
+    def get_value(self) -> float:
+        return self.value
+
+    def get_range(self) -> float:
+        return self.max_value - self.min_value
+
+    def get_ratio(self) -> float:
+        return self.value / (self.max_value - self.min_value)
+
+    def _build_content(self) -> None:
+        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)
+
+    def build(self) -> None:
+        super().build()
+        self._build_content()

batFramework/gui/radioButton.py

@@ -0,0 +1,62 @@
+import batFramework as bf
+from typing import Self,Any,Callable
+from .toggle import Toggle
+
+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 set_radio_value(self,value:Any)->Self:
+        self.radio_value = value
+        self.update_radio()
+        return self
+    
+    def set_text(self, text: str) -> Self:
+        flag = False
+        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
+        self.radio_variable.set_value(self.radio_value)
+
+class RadioVariable:
+    def __init__(self)->None:
+        self.buttons : list[RadioButton] = []
+        self.value = None
+        self.modify_callback : Callable[[Any],] = None
+
+    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() 
+        return 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
+        self.value = value
+        if self.modify_callback :self.modify_callback(value)
+        self.update_buttons() 
+
+    def update_buttons(self):
+        _ = [b.set_value(b.radio_value == self.value,False) for b in self.buttons]

batFramework/gui/root.py

@@ -5,36 +5,39 @@ import pygame
 
 
 class Root(InteractiveWidget):
-    def __init__(self,camera)->None:
+    def __init__(self, camera) -> None:
         super().__init__()
-        self.drawing_camera = camera
-        self.surface = None
-        self.set_root()
+        self.is_root = True
+        self.drawing_camera: bf.Camera = camera
+        self.visible = False
         self.rect.size = pygame.display.get_surface().get_size()
-        self.focused: InteractiveWidget |None= self
+        self.focused: InteractiveWidget | None = self
         self.hovered: Widget | None = self
-        self.set_debug_color("purple")
+        self.set_debug_color("yellow")
+        self.set_render_order(999)
+        self.clip_children = False
 
-    def to_string(self) -> str:
-        return "ROOT"
+    def __str__(self) -> str:
+        return "Root"
 
-    def to_string_id(self) -> str:
-        return "ROOT"
-        
     def get_focused(self) -> Widget | None:
         return self.focused
 
     def get_hovered(self) -> Widget | None:
         return self.hovered
 
-    def clear_focused(self)->None:
+    def clear_focused(self) -> None:
         self.focus_on(None)
 
-    def clear_hovered(self)->None:
-        if isinstance(self.hovered,InteractiveWidget):   self.hovered.on_exit()
+    def clear_hovered(self) -> None:
+        if isinstance(self.hovered, InteractiveWidget):
+            self.hovered.on_exit()
         self.hovered = None
 
-    def focus_on(self, widget: InteractiveWidget|None) -> None:
+    def focus_on(self, widget: InteractiveWidget | None) -> None:
+        if widget == self.focused : return
+        if widget and not widget.allow_focus_to_self():
+            return
         if self.focused is not None:
             self.focused.on_lose_focus()
         if widget is None:
@@ -43,59 +46,80 @@ class Root(InteractiveWidget):
         self.focused = widget
         self.focused.on_get_focus()
 
-    def set_size(self, width: float, height: float, force: bool = False) -> "Root":
+    def get_by_tags(self,*tags)->list[Widget]:
+        res = []
+        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):
+            if w.uid == uid:
+                return w
+            for child in w.children:
+                res = helper(child,uid)
+                if res : 
+                    return child
+                
+            return None
+        return helper(self,uid)
+
+    def set_size(self, size: tuple[float, float], force: bool = False) -> "Root":
         if not force:
             return self
-        self.rect.size = width, height
-        self.build(apply_constraints=True)
+        self.rect.size = size
+        # self.build(resolve_constraints=True)
         return self
 
-    def build(self, apply_constraints: bool = False) -> None:
-        if apply_constraints:
-            self.apply_all_constraints()
-        for child in self.children:
-            child.build()
 
     def do_handle_event(self, event):
-        if event.type == pygame.VIDEORESIZE:
-            self.set_size(event.w, event.h, force=True)
-            return True
+        # 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):
+            return
         if event.type == pygame.MOUSEBUTTONDOWN:
-            if self.hovered and isinstance(self.hovered,InteractiveWidget) :
-                self.hovered.on_click_down(event.button)
-        if event.type == pygame.MOUSEBUTTONUP:
-            if self.hovered and isinstance(self.hovered,InteractiveWidget) :
-                self.hovered.on_click_up(event.button)            
-
-        return False
+            self.hovered.on_click_down(event.button)
+        elif event.type == pygame.MOUSEBUTTONUP:
+            self.hovered.on_click_up(event.button)
 
-    def get_root(self) -> "Root" :
-        return self
 
-    def do_on_click_down(self,button:int)->None:
-        if button == 1 : self.clear_focused()
+    def do_on_click_down(self, button: int) -> None:
+        if button == 1:
+            self.clear_focused()
 
-    def top_at(self, x: float|int, y: float|int) -> "None|Widget":
+    def top_at(self, x: float | int, y: float | int) -> "None|Widget":
         if self.children:
             for child in reversed(self.children):
                 r = child.top_at(x, y)
                 if r is not None:
                     return r
-        return self if self.rect.collidepoint(x,y) else None
+        return self if self.rect.collidepoint(x, y) else None
 
     def update(self, dt: float) -> None:
         super().update(dt)
         old = self.hovered
-        transposed = self.drawing_camera.convert_screen_to_world(*pygame.mouse.get_pos())
-        self.hovered = (
-            self.top_at(*transposed)
-            if self.top_at(*transposed)
-            else None
-        )
-        if old == self.hovered:
+        transposed = self.drawing_camera.screen_to_world(pygame.mouse.get_pos())
+        self.hovered = self.top_at(*transposed) if self.top_at(*transposed) else None
+        if old == self.hovered and isinstance(self.hovered, InteractiveWidget):
+            self.hovered.on_mouse_motion(*transposed)
             return
-        if old and isinstance(old,InteractiveWidget):    
+        if old and isinstance(old, InteractiveWidget):
             old.on_exit()
-        if self.hovered and isinstance(self.hovered,InteractiveWidget) :
+        if self.hovered and isinstance(self.hovered, InteractiveWidget):
             self.hovered.on_enter()
 
+    def draw(self, camera: bf.Camera) -> int:
+        super().draw(camera)
+        if self.focused and self.focused!=self:
+            self.focused.draw_focused(camera)
+
+