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

batFramework/gui/meter.py

@@ -12,6 +12,7 @@ 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):
         super().__init__()
+        self.axis: bf.axis = bf.axis.HORIZONTAL
         self.min_value, self.max_value = min_value, max_value
         self.step = step
         self.snap: bool = False
@@ -29,6 +30,11 @@ class Meter(Shape):
     def __str__(self) -> str:
         return "Meter"
 
+    def set_axis(self,axis:bf.axis)->Self:
+        self.axis = axis
+        self.dirty_shape = True
+        return self
+
     def set_step(self, step: float) -> Self:
         self.step = step
         self.set_value(self.value)
@@ -36,9 +42,6 @@ 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
@@ -65,10 +68,21 @@ class Meter(Shape):
         return (self.value-self.min_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.rect.topleft = self.get_padded_rect().topleft
+        padded = self.get_inner_rect()
+        ratio = self.get_ratio()
+
+        if self.axis == bf.axis.HORIZONTAL:
+            width = padded.width * ratio
+            self.content.set_size((width, padded.height))
+            self.content.rect.topleft = padded.topleft
+
+        else:  # VERTICAL
+            height = padded.height * ratio
+            self.content.set_size((padded.width, height))
+            # Content grows from bottom up
+            self.content.rect.bottomleft = padded.bottomleft
+
 
     def build(self) -> None:
-        super().build()
         self._build_content()
+        super().build()

batFramework/gui/radioButton.py

@@ -3,7 +3,6 @@ from typing import Self, Any, Callable
 from .toggle import Toggle
 
 
-class RadioVariable: ...
 
 
 class RadioButton(Toggle):

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,36 @@ 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 event.consumed : return
+        self.do_handle_event_early(event)
+        if event.consumed : return
+        super().process_event(event)
+        
+    def do_handle_event_early(self, event):
+        if event.type == pygame.VIDEORESIZE:
+            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)):
             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 +148,68 @@ 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,257 @@
+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
+        self.indicator_height = 0
+        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_draw_stem(False)
+            .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_draw_stem(False)
+            .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 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(8, max_text_size[1] * 1.5)
+        total_height += self.unpressed_relief
+        total_height += max(self.right_indicator.outline_width,self.left_indicator.outline_width)
+        self.indicator_height = total_height
+
+        # Calculate total width and height
+        total_width = (
+            self.indicator_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 = self.indicator_height
+
+        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 build(self):
+        
+        super().build()
+        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.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.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.enabled:
+            indicator.on_click_down(1)
+            return True
+
+        return False
+
+    def on_key_up(self, key: int) -> bool:
+        if not self.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.enabled:
+            indicator.on_click_up(1)
+            return True
+
+        return False
+    
+    def do_on_click_down(self, button) -> None:
+        if self.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_padded_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],