batframework 1.0.10__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

batFramework/gui/radioButton.py

@@ -0,0 +1,43 @@
+import batFramework as bf
+from typing import Self, Any, Callable
+from .toggle import Toggle
+from .syncedVar import SyncedVar
+
+
+# TODO : RadioButton with no synced var ? click crashes
+
+class RadioButton(Toggle):
+    def __init__(self, text: str, synced_var: SyncedVar, 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.synced_var : SyncedVar = synced_var
+        self.synced_var.bind(self,self._update_state)
+
+    def __str__(self) -> str:
+        return f"RadioButton({self.radio_value}|{'Active' if self.value else 'Inactive'})"
+
+    def set_radio_value(self, value: Any) -> Self:
+        self.radio_value = value
+        return self
+
+    def set_value(self, value : bool, do_callback=False):
+        if self.value == value:
+            return self  # No change
+        self.value = value
+        self.indicator.set_value(value)
+        self.dirty_surface = True
+
+        # Update SyncedVar only if different (avoid recursion)
+        if value and self.synced_var.value != self.radio_value:
+            self.synced_var.value = self.radio_value
+
+        if do_callback and self.callback:
+            self.callback(self.value)
+        return self
+        # if value : self.synced_var.value = self.radio_value
+
+    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

@@ -1,60 +1,228 @@
-import batFramework as bf
-from .interactiveWidget import InteractiveWidget
-from .widget import Widget
-import pygame
-
-class Root(InteractiveWidget):
-    def __init__(self):
-        super().__init__()
-        self.surface = None
-        self.set_root()
-        self.rect.size = pygame.display.get_surface().get_size()
-        self.focused : InteractiveWidget = self
-        self.hovered : Widget|None = self
-        self.set_debug_color("purple")
-
-    def to_string(self)->str:
-         return "ROOT"
-
-    def get_focused(self)->Widget|None:
-        return self.focused
-
-    def get_hovered(self)->Widget|None:
-        return self.hovered
-         
-    def to_string_id(self)->str:
-        return "ROOT"
-
-    def focus_on(self,widget:InteractiveWidget)->None:
-        if self.focused is not None: 
-            self.focused.on_lose_focus()
-        if widget is None :
-            self.focused = self
-            return
-        self.focused= widget
-        self.focused.on_get_focus()
-
-    def set_size(self,width:float,height:float,force:bool=False)->"Root":
-        if not force :  return self
-        self.rect.size = width,height
-        self.build(apply_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
-        return False
-
-    def update(self,dt:float)->None:
-        super().update(dt)
-        self.hovered = self.top_at(*pygame.mouse.get_pos()) if self.top_at(*pygame.mouse.get_pos()) else None
-        
-
-
-        
+import batFramework as bf
+from .interactiveWidget import InteractiveWidget
+from .widget import Widget
+import pygame
+from typing import Self
+import sys
+
+
+class Root(InteractiveWidget):
+    def __init__(self, camera) -> None:
+        super().__init__()
+        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.hovered: Widget | None = self
+        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)
+        self.set_click_pass_through(True)
+
+    def set_show_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:Widget, depth):
+            prefix = " " * (depth * 4) + ("L__ " 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:
+        return super().set_parent_scene(parent_scene)
+
+    def get_focused(self) -> Widget | None:
+        return self.focused
+
+    def get_hovered(self) -> Widget | None:
+        return self.hovered
+
+    def clear_focused(self) -> None:
+        self.focus_on(None)
+
+    def clear_hovered(self) -> None:
+        if isinstance(self.hovered, 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 and not widget.allow_focus_to_self():
+            return
+        if self.focused is not None:
+            self.focused.on_lose_focus()
+        if widget is None:
+            self.focused = self
+            return
+        self.focused = widget
+        self.focused.on_get_focus()
+
+    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 focus_next_tab(self, widget):
+        return
+
+    def focus_prev_tab(self, widget):
+        return
+
+    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 is not None:
+                    return res
+            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 = size
+        self.dirty_shape = True
+        self.dirty_size_constraints = True
+        return self
+
+    def process_event(self,event):
+        if not event.consumed : self.handle_event_early(event)
+        super().process_event(event)
+        
+    def 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)
+        return
+    
+    def handle_event(self, event):
+        super().handle_event(event)
+        if not event.consumed :
+            if event.type == pygame.KEYDOWN and event.key==pygame.K_TAB:
+                self.tab_focus(event)
+
+    def tab_focus(self,event=None):
+        if self.focused is None:
+            return
+        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)
+        if event :event.consumed = True
+
+
+    def on_click_down(self, button: int,event) -> None:
+        if button == 1:
+            self.clear_focused()
+        super().on_click_down(button,event)
+
+    def top_at(self, x: float | int, y: float | int) -> "None|Widget":
+        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
+
+    def update(self, dt: float) -> None:
+        super().update(dt)
+        self.update_tree()
+
+        mouse_world = self.drawing_camera.get_mouse_pos()
+        prev_hovered = self.hovered
+        self.hovered = self.top_at(*mouse_world)
+
+        if (self.hovered and self.hovered.tooltip_text and self.show_tooltip):
+            self.tooltip.set_text(self.hovered.tooltip_text)
+            self.tooltip.fade_in()
+        else:
+            self.tooltip.fade_out()
+
+        # Tooltip logic
+        if self.tooltip.visible: 
+
+            tooltip_size = self.tooltip.get_min_required_size()
+            # screen_w, screen_h = self.drawing_camera.rect.size
+            screen_w, screen_h = bf.const.RESOLUTION
+
+            tooltip_x, tooltip_y = mouse_world
+            tooltip_x+=4
+            tooltip_y+=4
+            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)
+
+        if self.hovered == prev_hovered:
+            if isinstance(self.hovered, InteractiveWidget):
+                self.hovered.on_mouse_motion(*mouse_world)
+            return
+
+        if isinstance(prev_hovered, InteractiveWidget):
+            prev_hovered.on_exit()
+        if isinstance(self.hovered, InteractiveWidget):
+            self.hovered.on_enter()
+
+
+
+
+    def update_tree(self):
+        # 1st pass
+        self.apply_updates("pre")
+        self.apply_updates("post")
+        # 2nd pass
+        # self.apply_updates("pre")
+        # self.apply_updates("post")
+
+
+    def apply_pre_updates(self):
+        return 
+
+    def apply_post_updates(self, skip_draw = False):
+        return
+
+    def draw(self, camera: bf.Camera) -> None:
+        if self.clip_children:
+            new_clip = camera.world_to_screen(self.get_inner_rect())
+            old_clip = camera.surface.get_clip()
+            camera.surface.set_clip(new_clip)
+
+        # Draw each child widget, sorted by render order
+        for child in [c for c in self.children if c != self.tooltip]:
+            if (not self.clip_children) or (child.rect.colliderect(self.rect) or not child.rect):
+                child.draw(camera)
+        if self.clip_children:
+            camera.surface.set_clip(old_clip)
+        
+        if self.focused != self and (not self.focused is None)  :
+            old_clip = camera.surface.get_clip()
+            camera.surface.set_clip(self.focused.parent.get_inner_rect())
+            self.focused.draw_focused(camera)   
+            camera.surface.set_clip(old_clip)
+
+        self.tooltip.draw(camera)

batFramework/gui/scrollingContainer.py

@@ -0,0 +1,282 @@
+from typing import Self
+import pygame
+from .slider import Slider
+import batFramework as bf
+from .syncedVar import SyncedVar
+from .container import Container
+from .constraints.constraints import FillX, FillY
+from .widget import Widget
+from .shape import Shape
+
+class ScrollBar(Slider):
+    def do_when_added(self):
+        super().do_when_added()
+        self.meter.add_constraints(FillX(), FillY())
+        self.set_clip_children(False)
+        self.set_pressed_relief(0).set_unpressed_relief(0)
+        self.meter.content.set_color(None)
+
+    def __str__(self):
+        return "Scrollbar"
+
+    def _on_synced_var_update(self, value):
+        self.dirty_shape = True # build uses synced var directly so we just trigger build via dirty shape
+        if self.modify_callback:
+            self.modify_callback(value)
+
+    def on_get_focus(self) -> None:
+        self.is_focused = True
+        self.do_on_get_focus()
+
+    def draw_focused(self, camera):
+        return
+    
+    def paint(self) -> None:
+        Shape.paint(self)
+ 
+
+class ScrollingContainer(Container):
+    """
+    Should work for single and double axis standard layouts 
+    """
+    def __init__(self, layout=None, *children):
+        super().__init__(layout, *children)
+        self.sync_scroll_x= SyncedVar(0) # 0 to 1
+        self.sync_scroll_y= SyncedVar(0) # 0 to 1
+
+        self.scrollbar_size = 8
+        self.scrollbars_needed = [False, False]  # [horizontal, vertical]
+        
+        # Create scrollbars
+        self.y_scrollbar = (
+            ScrollBar("", 0, synced_var=self.sync_scroll_y)
+            .set_axis(bf.axis.VERTICAL)
+            .set_autoresize(False)
+            .set_padding(0)
+            .set_direction(bf.direction.DOWN)
+            .set_step(0.01)
+        )
+        self.y_scrollbar.meter.handle.set_autoresize_h(False)
+
+        self.x_scrollbar = (
+            ScrollBar("", 0, synced_var=self.sync_scroll_x)
+            .set_autoresize(False)
+            .set_padding(0)
+            .set_step(0.01)
+        )
+
+        self.x_scrollbar.meter.handle.set_autoresize_w(False)
+
+        self.sync_scroll_x.bind(self,lambda v : self.on_sync_update((v,self.sync_scroll_y.value)))
+        self.sync_scroll_y.bind(self,lambda v : self.on_sync_update((self.sync_scroll_x.value,v)))
+
+
+        # Add scrollbars but initially hide them
+        self.add(
+            self.y_scrollbar,
+            self.x_scrollbar
+            )
+        self.x_scrollbar.hide()
+        self.y_scrollbar.hide()
+
+    def __str__(self):
+        return "Scrolling"+ super().__str__()
+
+    def set_scroll(self,value):
+        # print("Scrolling set scroll called", value)
+        self.sync_scroll_x.value = self.x_scroll_scaled_to_normalized(value[0])
+        self.sync_scroll_y.value = self.y_scroll_scaled_to_normalized(value[1])
+
+
+    def on_sync_update(self,value):
+        # print("Scrolling on sync update called", value)
+        value = [self.x_scroll_normalized_to_scaled(value[0]),self.y_scroll_normalized_to_scaled(value[1])]
+        super().set_scroll(value)
+
+
+    def set_scrollbar_size(self, size:int)->Self:
+        self.scrollbar_size = size
+        self.dirty_layout= True
+        self.dirty_shape = True
+        return self
+
+    def y_scroll_normalized_to_scaled(self, value):
+        inner_height = self.get_inner_height()
+        content_height = self.layout.children_rect.h  # total content height
+
+        max_scroll = max(0, content_height - inner_height)
+        converted_y = value * max_scroll
+
+        return converted_y
+
+    def x_scroll_normalized_to_scaled(self, value):
+        inner_width = self.get_inner_width()
+        content_width = self.layout.children_rect.w  # total content width
+
+        max_scroll = max(0, content_width - inner_width)
+        converted_x = value * max_scroll
+
+        return converted_x
+
+    def y_scroll_scaled_to_normalized(self, value):
+        inner_height = self.get_inner_height()
+        content_height = self.layout.children_rect.h
+
+        max_scroll = max(0, content_height - inner_height)
+        if max_scroll == 0:
+            return 0
+        return value / max_scroll
+
+    def x_scroll_scaled_to_normalized(self, value):
+        inner_width = self.get_inner_width()
+        content_width = self.layout.children_rect.w
+
+        max_scroll = max(0, content_width - inner_width)
+        if max_scroll == 0:
+            return 0
+        return value / max_scroll
+
+
+
+    def get_layout_children(self):
+        return [c for c in super().get_layout_children() if c not in [self.y_scrollbar,self.x_scrollbar]]
+    
+    def get_interactive_children(self):
+        return [c for c in super().get_interactive_children() if c not in [self.y_scrollbar,self.x_scrollbar]]
+
+    def top_at(self, x, y):
+        res = self.y_scrollbar.top_at(x,y)
+        if res: return res
+        res = self.x_scrollbar.top_at(x,y)
+        if res: return res        
+        return super().top_at(x, y)
+
+
+    def get_inner_width(self):
+        r = super().get_inner_width()
+        if not  self.scrollbars_needed[1]:
+            return r
+        return r - self.scrollbar_size
+
+    def get_inner_height(self):
+        r = super().get_inner_height()
+        if  not self.scrollbars_needed[0]:
+            return r
+        return r - self.scrollbar_size
+    
+    def get_inner_rect(self):
+        r = super().get_inner_rect()
+        if   self.scrollbars_needed[1] : 
+            r.w -= self.scrollbar_size
+        if   self.scrollbars_needed[0] :
+            r.h -= self.scrollbar_size
+        return r
+
+
+    def expand_rect_with_padding(self, rect):
+        r = super().expand_rect_with_padding(rect)
+
+        if  self.scrollbars_needed[1] : 
+            r.w += self.scrollbar_size
+        if  self.scrollbars_needed[0] :
+            r.h += self.scrollbar_size
+        return r
+    
+    def _update_scrollbars(self):
+        # print("Update scrollbar")
+        if self.layout.children_rect.h == 0:
+            y_ratio = 1 # set to 1 so no need to scroll
+        else:
+            y_ratio = self.get_inner_height() / self.layout.children_rect.h
+        if self.layout.children_rect.w == 0:
+            x_ratio = 1
+        else:
+            x_ratio = self.get_inner_width() / self.layout.children_rect.w
+
+
+        tmp_scrollbars_needed = [
+            x_ratio < 1,
+            y_ratio < 1 
+        ]
+        visible_list = [self.x_scrollbar.visible,self.y_scrollbar.visible]
+        # print(f"{tmp_scrollbars_needed=}")
+        
+        # print(f"{self.scrollbars_needed=}")
+
+        # print(f"{x_ratio=}")
+        # print(f"{y_ratio=}")
+
+
+        # check if scrollbars changed (remove or add)
+        if self.scrollbars_needed != tmp_scrollbars_needed :
+            # self.dirty_shape = True # because scrollbars change self shape
+            self.x_scrollbar.show() if tmp_scrollbars_needed[0] else self.x_scrollbar.hide()
+            self.y_scrollbar.show() if tmp_scrollbars_needed[1] else self.y_scrollbar.hide()
+        
+            self.scrollbars_needed = tmp_scrollbars_needed
+            
+
+
+
+        if self.x_scrollbar.visible:
+            self.x_scrollbar.set_size((self.rect.w-(self.scrollbar_size if tmp_scrollbars_needed[1] else 0),self.scrollbar_size))
+            self.x_scrollbar.set_position(self.rect.left,self.rect.bottom - self.scrollbar_size)
+            self.x_scrollbar.meter.handle.set_size((max(2,self.get_inner_width()*x_ratio),None))
+        if self.y_scrollbar.visible:
+            self.y_scrollbar.set_size((self.scrollbar_size,self.rect.h))
+            self.y_scrollbar.set_position(self.rect.right - self.scrollbar_size,self.rect.top)
+            self.y_scrollbar.meter.handle.set_size((None,max(self.get_inner_height()*y_ratio,2)))
+        
+
+
+
+
+
+
+    def build(self) -> None:
+        if self.layout is not None:
+            size = list(self.layout.get_auto_size())
+            size[0]+=self.scrollbar_size
+            size[1]+=self.scrollbar_size
+            self.set_size(self.resolve_size(size))
+        return super().build()
+
+    def apply_pre_updates(self):
+        if self.dirty_size_constraints or self.dirty_shape:
+            self.resolve_constraints(size_only=True)
+            self.dirty_size_constraints = False
+            self.dirty_position_constraints = True
+
+        if self.dirty_layout:
+            self.layout.update_child_constraints()
+            self.layout.arrange()
+            self.dirty_layout = False
+            self.dirty_scroll = True
+
+        if self.dirty_scroll:
+            self.layout.scroll_children()
+            self._update_scrollbars()
+            self.dirty_scroll = False
+
+
+        
+
+
+    def draw(self, camera):
+        bf.Drawable.draw(self,camera)
+
+        if self.clip_children:
+            new_clip = camera.world_to_screen(self.get_inner_rect())
+            old_clip = camera.surface.get_clip()
+            new_clip = new_clip.clip(old_clip)
+            camera.surface.set_clip(new_clip)
+
+        # Draw each child widget, sorted by render order
+        for child in self.children:
+            if (not self.clip_children) or (child.rect.colliderect(self.rect) or not child.rect):
+                child.draw(camera)
+        if self.clip_children:
+            camera.surface.set_clip(old_clip)
+
+        self.y_scrollbar.draw(camera)
+        self.x_scrollbar.draw(camera)