batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

batFramework/gui/meter.py

@@ -1,3 +1,4 @@
+import math
 import batFramework as bf
 from .shape import Shape
 from typing import Self
@@ -8,7 +9,6 @@ def custom_top_at(self, x, y):
         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__()
@@ -16,14 +16,6 @@ class Meter(Shape):
         self.step = step
         self.snap: bool = False
         self.value = self.max_value
-        self.content = Shape((0, 0)).set_color(bf.color.BLUE)
-        self.content.set_debug_color("cyan")
-        self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
-        self.add(self.content)
-        self.set_padding(4)
-        self.set_color("gray20")
-        self.set_outline_width(1)
-        self.set_outline_color(bf.color.BLACK)
         self.set_debug_color("pink")
 
     def __str__(self) -> str:
@@ -36,18 +28,11 @@ class Meter(Shape):
 
     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 = range_min
         self.max_value = 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
@@ -64,11 +49,48 @@ class Meter(Shape):
     def get_ratio(self) -> float:
         return (self.value-self.min_value) / (self.max_value - self.min_value)
 
+
+class BarMeter(Meter):
+    def __init__(self, min_value: float = 0, max_value: float = 1, step: float = 0.1):
+        super().__init__(min_value, max_value, step)
+        self.axis: bf.axis = bf.axis.HORIZONTAL
+        self.content = Shape((0, 0)).set_color(bf.color.BLUE)
+        self.content.set_debug_color("cyan")
+        self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
+        self.add(self.content)
+        self.set_padding(4)
+        self.set_color("gray20")
+        self.set_outline_width(1)
+        self.set_outline_color(bf.color.BLACK)
+        self.set_debug_color("pink")
+
+    def __str__(self) -> str:
+        return "BarMeter"
+
+    def set_axis(self,axis:bf.axis)->Self:
+        self.axis = axis
+        self.dirty_shape = True
+        return self
+
     def _build_content(self) -> None:
-        width = self.get_padded_width() * self.get_ratio()
-        self.content.set_size((width, self.get_padded_height()))
-        self.content.rect.topleft = self.get_padded_rect().topleft
+        padded = self.get_inner_rect()
+        ratio = self.get_ratio()
+
+        self.content.set_border_radius(*[round(b/2) for b in self.border_radius])
+
+        if self.axis == bf.axis.HORIZONTAL:
+            width = (padded.width- self.outline_width *2) * ratio 
+            self.content.set_size((width, padded.height - self.outline_width*2))
+            self.content.rect.topleft = padded.move(self.outline_width, self.outline_width).topleft
+
+        else:  # vertical
+            height = (padded.height - self.outline_width * 2) * ratio
+            self.content.set_size((padded.width - self.outline_width * 2, height))
+            self.content.rect.bottomleft = (
+                padded.move(self.outline_width,-self.outline_width).bottomleft 
+            )
+            self.content.rect.height = math.ceil(self.content.rect.height)
 
     def build(self) -> None:
-        super().build()
         self._build_content()
+        super().build()

batFramework/gui/radioButton.py

@@ -1,84 +1,35 @@
 import batFramework as bf
 from typing import Self, Any, Callable
 from .toggle import Toggle
-
-
-class RadioVariable: ...
+from .syncedVar import SyncedVar
 
 
 class RadioButton(Toggle):
-    def __init__(self, text: str = "", radio_value: Any = None) -> None:
+    def __init__(self, text: str = "", radio_value: Any = None, synced_var: SyncedVar = 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
+        self.radio_value: Any = radio_value if radio_value is not None else text if text else None
+        self.synced_var : SyncedVar = None
+        if synced_var:
+            self.link(synced_var)
+
+    def link(self,synced_var:SyncedVar)->Self:
+        self.synced_var = synced_var
+        synced_var.bind_widget(self,self._update_state)
+        return self
 
     def __str__(self) -> str:
-        return (
-            f"RadioButton({self.radio_value}|{'Active' if self.value else 'Inactive'})"
-        )
+        return f"RadioButton({self.radio_value}|{'Active' if self.value else 'Inactive'})"
 
     def set_radio_value(self, value: Any) -> Self:
         self.radio_value = value
-
-        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
-        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[[bool],Any] = None
-
-    def set_modify_callback(self, callback:Callable[[bool],Any]) -> Self:
-        self.modify_callback = callback
-        return self
-
-    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) -> Self:
-        if value == self.value:
-            return
-        self.value = value
-        if self.modify_callback:
-            self.modify_callback(value)
-        self.update_buttons()
-        return self
+    def set_value(self, value : bool, do_callback=False):
+        super().set_value(value, do_callback)
+        if value : self.synced_var.value = self.radio_value
 
-    def update_buttons(self):
-        _ = [b.set_value(b.radio_value == self.value, False) for b in self.buttons]
+    def _update_state(self, synced_value: Any) -> None:
+        """
+        Updates the state of the RadioButton based on the synced variable's value.
+        """
+        self.set_value(self.radio_value == synced_value, False)

batFramework/gui/root.py

@@ -15,15 +15,28 @@ class Root(InteractiveWidget):
         self.rect.size = pygame.display.get_surface().get_size()
         self.focused: InteractiveWidget | None = self
         self.hovered: Widget | None = self
-        self.set_debug_color("yellow")
-        self.set_render_order(sys.maxsize)
         self.clip_children = False
+        self.set_debug_color("yellow")
 
+        self.show_tooltip : bool = True
+        self.tooltip = bf.gui.ToolTip("").set_visible(False)
+        self.add(self.tooltip)
+
+    def toggle_tooltip(self,value:bool)->Self:
+        self.show_tooltip = value
+        return self
+    
     def __str__(self) -> str:
         return "Root"
+    
+    def to_ascii_tree(self) -> str:
+        def f(w, depth):
+            prefix = " " * (depth * 4) + ("└── " if depth > 0 else "")
+            children = "\n".join(f(c, depth + 1) for c in w.children) if w.children else ""
+            return f"{prefix}{str(w)}\n{children}"
+        return f(self, 0)
 
     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:
@@ -91,28 +104,35 @@ class Root(InteractiveWidget):
         if not force:
             return self
         self.rect.size = size
+        self.dirty_shape = True
+        self.dirty_size_constraints = True
         return self
 
-    def do_handle_event(self, event):
+    def process_event(self,event):
+        if not event.consumed : self.do_handle_event_early(event)
+        if not event.consumed : super().process_event(event)
+        
+    def do_handle_event_early(self, event):
+        if event.type == pygame.VIDEORESIZE and not pygame.SCALED & bf.const.FLAGS:
+            self.set_size((event.w,event.h),force=True)
         if self.focused:
             if event.type == pygame.KEYDOWN:
-                if self.focused.on_key_down(event.key):
-                    event.consumed = True
+                event.consumed = self.focused.on_key_down(event.key)
+                if not event.consumed : 
+                    event.consumed = self._handle_alt_tab(event.key)
             elif event.type == pygame.KEYUP:
-                if self.focused.on_key_up(event.key):
-                    event.consumed = True
+                event.consumed = self.focused.on_key_up(event.key)
 
         if not self.hovered or (not isinstance(self.hovered, InteractiveWidget)):
+            event.consumed = True
             return
 
         if event.type == pygame.MOUSEBUTTONDOWN:
-            if self.hovered.on_click_down(event.button):
-                event.consumed = True
+            event.consumed = self.hovered.on_click_down(event.button)
 
         elif event.type == pygame.MOUSEBUTTONUP:
-            if self.hovered.on_click_up(event.button):
-                event.consumed = True
-
+            event.consumed = self.hovered.on_click_up(event.button)
+            
     def do_on_click_down(self, button: int) -> None:
         if button == 1:
             self.clear_focused()
@@ -127,25 +147,69 @@ class Root(InteractiveWidget):
 
     def update(self, dt: float) -> None:
         super().update(dt)
-        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)
+        self.update_tree()
+
+        mouse_screen = pygame.mouse.get_pos()
+        mouse_world = self.drawing_camera.screen_to_world(mouse_screen)
+        prev_hovered = self.hovered
+        self.hovered = self.top_at(*mouse_world) or None
+
+        # Tooltip logic
+        if self.hovered and self.hovered.tooltip_text:
+            self.tooltip.set_text(self.hovered.tooltip_text)
+
+            tooltip_size = self.tooltip.get_min_required_size()
+            screen_w, screen_h = self.drawing_camera.rect.size
+            tooltip_x, tooltip_y = self.drawing_camera.world_to_screen_point(mouse_world)
+
+            tooltip_x = min(tooltip_x, screen_w - tooltip_size[0])
+            tooltip_y = min(tooltip_y, screen_h - tooltip_size[1])
+            tooltip_x = max(0, tooltip_x)
+            tooltip_y = max(0, tooltip_y)
+
+            self.tooltip.set_position(tooltip_x, tooltip_y)
+            self.tooltip.fade_in()
+        else:
+            self.tooltip.fade_out()
+
+        if self.hovered == prev_hovered:
+            if isinstance(self.hovered, InteractiveWidget):
+                self.hovered.on_mouse_motion(*mouse_world)
             return
-        if old and isinstance(old, InteractiveWidget):
-            old.on_exit()
-        if self.hovered and isinstance(self.hovered, InteractiveWidget):
+
+        if isinstance(prev_hovered, InteractiveWidget):
+            prev_hovered.on_exit()
+        if isinstance(self.hovered, InteractiveWidget):
             self.hovered.on_enter()
 
-    def apply_updates(self):
-        if any(child.dirty_shape for child in self.children):
-            self.dirty_shape = True  # Mark layout as dirty if any child changed size
 
-        if self.dirty_shape:
-            for child in self.children:
-                child.apply_updates()
-            self.dirty_shape = False
+    def _handle_alt_tab(self,key):
+        if self.focused is None:
+            return False
+        if key != pygame.K_TAB:
+            return False
+        keys = pygame.key.get_pressed()
+        if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
+            self.focused.focus_prev_tab(self.focused)
+        else:
+            self.focused.focus_next_tab(self.focused)
+        return True
+
+    def update_tree(self):
+        # print("START updating tree")
+        self.apply_updates("pre")
+        self.apply_updates("post")
+
+        self.apply_updates("pre")
+        self.apply_updates("post")
+
+        # print("END updating tree")
+
+    def apply_pre_updates(self):
+        return 
+
+    def apply_post_updates(self, skip_draw = False):
+        return
 
     def draw(self, camera: bf.Camera) -> None:
         super().draw(camera)
@@ -155,4 +219,10 @@ class Root(InteractiveWidget):
             and self.focused
             and self.focused != self
         ):
-            self.focused.draw_focused(camera)
+            clip:bool =self.focused.parent and self.focused.parent.clip_children
+            if clip:
+                old_clip = camera.surface.get_clip()
+                camera.surface.set_clip(camera.world_to_screen(self.focused.parent.rect))    
+            if clip:
+                camera.surface.set_clip(old_clip)
+            self.focused.draw_focused(camera)   

batFramework/gui/selector.py

@@ -0,0 +1,250 @@
+import batFramework as bf
+import pygame
+from typing import Self,Callable,Any
+from .button import Button
+from .indicator import ArrowIndicator
+from .clickableWidget import ClickableWidget
+from .widget import Widget
+
+class MyArrow(ArrowIndicator,ClickableWidget):
+    def top_at(self,x,y):
+        return Widget.top_at(self,x,y)
+
+    def get_focus(self):
+        return self.parent.get_focus()
+
+class Selector(Button):
+    def __init__(self,options:list[str]=None,default_value:str=None,allow_cycle:bool=False):
+        super().__init__('')
+        self.allow_cycle = allow_cycle
+        self.current_index = 0
+        self.on_modify_callback : Callable[[str,int],Any] = None
+        self.options = options if options else []
+        self.gap : int = 2
+        text_value = ""
+
+        
+        if not (default_value is not None and default_value in self.options): 
+            default_value = options[0]
+            
+        text_value = default_value  
+        self.current_index = self.options.index(default_value)
+
+        self.left_indicator : MyArrow = (MyArrow(bf.direction.LEFT)
+            .set_color((0,0,0,0)).set_arrow_color(self.text_color)
+            .set_callback(lambda : self.set_by_index(self.get_current_index()-1))
+        )
+
+        self.right_indicator:MyArrow =(MyArrow(bf.direction.RIGHT)
+            .set_color((0,0,0,0)).set_arrow_color(self.text_color)
+            .set_callback(lambda : self.set_by_index(self.get_current_index()+1))
+        )
+        
+        self.add(self.left_indicator,self.right_indicator)
+        self.set_clip_children(False)
+        self.set_text(text_value)
+
+    def __str__(self):
+        return f"Selector[{self.options[self.current_index]}]"
+
+    def set_gap(self,value:int)->Self:
+        self.gap = value
+        self.dirty_shape = True
+        return self
+    
+    def set_arrow_color(self,color)->Self:
+        self.left_indicator.set_arrow_color(color)
+        self.right_indicator.set_arrow_color(color)
+        return self
+
+    def disable(self):
+        super().disable()
+        self.left_indicator.disable()
+        self.right_indicator.disable()
+        return self
+    
+    def enable(self):
+        super().enable()
+        self.right_indicator.enable()
+        self.left_indicator.enable()
+        index = self.current_index
+        if not self.allow_cycle:
+            if index == 0:
+                self.left_indicator.disable()
+            else:
+                self.left_indicator.enable()
+            if index == len(self.options)-1:
+                self.right_indicator.disable()
+            else:
+                self.right_indicator.enable()
+
+
+        return self
+
+    def set_tooltip_text(self, text):
+        self.left_indicator.set_tooltip_text(text)
+        self.right_indicator.set_tooltip_text(text)
+        return super().set_tooltip_text(text)
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        """
+        Calculates the minimum size required for the selector, including text and indicators.
+        """
+
+        # Calculate the maximum size needed for the text
+        old_text = self.text
+        max_text_size = (0, 0)
+        for option in self.options:
+            self.text = option
+            text_size = self._get_text_rect_required_size()
+            max_text_size = max(max_text_size[0], text_size[0]), max(max_text_size[1], text_size[1])
+        self.text = old_text
+
+        # Ensure total_height is always an odd integer
+        total_height = max(self.font_object.get_height()+1, max_text_size[1] * 1.5)
+        total_height += self.unpressed_relief
+        total_height += max(self.right_indicator.outline_width,self.left_indicator.outline_width)
+
+        # Calculate total width and height
+        total_width = (
+            total_height*2+
+            max_text_size[0] +  # Text width
+            self.gap * 2      # Gaps between text and indicators
+        )
+        # Inflate by padding at the very end
+        final_size = self.expand_rect_with_padding((0, 0, total_width, total_height)).size
+
+        return final_size
+
+    def _align_content(self):
+        """
+        Builds the selector layout (places and resizes the indicators)
+        """
+
+        # return
+        # Step 1: Calculate the padded area for positioning
+        padded = self.get_inner_rect()
+
+    
+        # left_size = self.left_indicator.rect.size
+        right_size = self.right_indicator.rect.size
+
+        indicator_height = padded.h
+
+        self.left_indicator.set_size((indicator_height,indicator_height))
+        self.right_indicator.set_size((indicator_height,indicator_height))
+
+
+        # Step 3: Position indicators
+        self.left_indicator.set_position(padded.left, None)
+        self.left_indicator.set_center(None, padded.centery)
+
+        self.right_indicator.set_position(padded.right - right_size[0], None)
+        self.right_indicator.set_center(None, padded.centery)
+
+    def apply_post_updates(self, skip_draw = False):
+        super().apply_post_updates(skip_draw)
+        self._align_content()
+
+    def get_current_index(self)->int:
+        return self.current_index
+
+    def set_allow_cycle(self,value:bool)->Self:
+        if value == self.allow_cycle: return self
+        self.allow_cycle = value
+        self.dirty_surface = True
+        return self
+
+    def set_text_color(self,color)->Self:
+        super().set_text_color(color)
+        self.left_indicator.set_arrow_color(color)
+        self.right_indicator.set_arrow_color(color)
+        return self
+
+    def set_modify_callback(self,function:Callable[[str,int],Any]):
+        """
+        the function will receive the value and the index 
+        """
+        self.on_modify_callback = function
+        return self
+
+    def set_by_index(self,index:int)->Self:
+        if self.allow_cycle:
+            index = index%len(self.options)
+        else:
+            index = max(min(len(self.options)-1,index),0)
+    
+        if index == self.current_index:
+            return self
+
+        self.current_index = index
+        self.set_text(self.options[self.current_index])
+        if self.on_modify_callback:
+            self.on_modify_callback(self.options[self.current_index],self.current_index)
+        if not self.allow_cycle:
+            if index == 0:
+                self.left_indicator.disable()
+            else:
+                self.left_indicator.enable()
+            if index == len(self.options)-1:
+                self.right_indicator.disable()
+            else:
+                self.right_indicator.enable()
+        return self
+
+    def paint(self):
+        super().paint()
+        self.left_indicator.show()
+        self.right_indicator.show()
+        if not self.allow_cycle and self.current_index == 0:
+            self.left_indicator.hide()
+        elif not self.allow_cycle and self.current_index== len(self.options)-1:
+            self.right_indicator.hide()
+            
+    def set_by_value(self,value:str)->Self:
+        if not self.is_enabled : return
+        if value not in self.options : return self
+        index = self.options.index(value)
+        self.set_by_index(index)
+        return self
+
+    def on_key_down(self, key: int) -> bool:
+        if not self.is_enabled:
+            return False
+
+        key_actions = {
+            pygame.K_RIGHT: self.right_indicator,
+            pygame.K_SPACE: self.right_indicator,
+            pygame.K_LEFT: self.left_indicator
+        }
+
+        indicator = key_actions.get(key)
+        if indicator and indicator.visible and indicator.is_enabled:
+            indicator.on_click_down(1)
+            return True
+
+        return False
+
+    def on_key_up(self, key: int) -> bool:
+        if not self.is_enabled:
+            return False
+
+        key_actions = {
+            pygame.K_RIGHT: self.right_indicator,
+            pygame.K_SPACE: self.right_indicator,
+            pygame.K_LEFT: self.left_indicator
+        }
+
+        indicator = key_actions.get(key)
+        if indicator and indicator.visible and indicator.is_enabled:
+            indicator.on_click_up(1)
+            return True
+
+        return False
+    
+    def do_on_click_down(self, button) -> None:
+        if self.is_enabled and button == 1:
+            if not self.get_focus():
+                return True
+        return False
+

batFramework/gui/shape.py

@@ -18,16 +18,24 @@ class Shape(Widget):
         self.shadow_color: tuple[int, int, int] | str = (0, 0, 0, 255)
         self.draw_mode = bf.drawMode.SOLID
 
-    def get_padded_bottom(self) -> float:
+    def get_inner_bottom(self) -> float:
         return self.rect.bottom - self.padding[3] - self.relief
 
-    def get_padded_height(self) -> float:
+    def get_inner_height(self) -> float:
         return self.rect.h - self.padding[1] - self.padding[3] - self.relief
 
-    def get_padded_top(self) -> float:
-        return self.rect.y + self.relief
+    def get_inner_top(self) -> float:
+        return self.rect.y + self.padding[1]
 
-    def get_padded_rect(self) -> pygame.FRect:
+    def get_local_inner_rect(self)->pygame.FRect:
+        return pygame.FRect(
+            self.padding[0],
+            self.padding[1],
+            self.rect.w - self.padding[2] - self.padding[0],
+            self.rect.h - self.padding[1] - self.padding[3] - self.relief,
+        )
+
+    def get_inner_rect(self) -> pygame.FRect:
         return pygame.FRect(
             self.rect.x + self.padding[0],
             self.rect.y + self.padding[1],