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

batFramework/gui/button.py

@@ -1,84 +1,18 @@
-from .label import Label
-import batFramework as bf
-from types import FunctionType
-from typing import Self
-from .interactiveWidget import InteractiveWidget
-import pygame
-
-class Button(Label,InteractiveWidget):
-    _cache = {}
-    
-    def __init__(self, text: str, callback : FunctionType =None) -> None:
-        # Label.__init__(self,text) 
-        self.callback = callback    
-        self.click_action = bf.Action("click").add_mouse_control(1)
-        self.hover_action = bf.Action("hover").add_mouse_control(pygame.MOUSEMOTION)
-        self.is_hovered : bool = False
-        self.is_clicking : bool = False
-        super().__init__(text=text)
-        self.set_debug_color("cyan")
-
-
-    def set_callback(self,callback : FunctionType = None)->Self:
-        self.callback = callback
-        return self
-
-    def on_get_focus(self):
-        super().on_get_focus()
-        self.build()
-
-    def on_lose_focus(self):
-        super().on_lose_focus()
-        self.build()
-
-    def to_string_id(self)->str:
-        return f"Button({self._text})"   
-
-    def click(self)->None:
-        if self.callback and not self.is_clicking:
-            self.is_clicking = True
-            self.callback()
-            self.is_clicking = False
-            
-            
-    def do_process_actions(self,event):
-        self.click_action.process_event(event)
-        self.hover_action.process_event(event)
-
-    def do_reset_actions(self):
-        self.click_action.reset()
-        self.hover_action.reset()
-
-    def do_handle_event(self,event)->None:
-        res = False
-        if self.click_action.is_active():
-            root = self.get_root()
-            if root.hovered ==  self:
-                if not self.is_focused :  self.get_focus()
-                self.click()
-        elif self.hover_action.is_active():
-            root = self.get_root()
-            if root:
-                if self.is_hovered and root.hovered != self:
-                    self.is_hovered = False
-                    self.build()
-                if not self.is_hovered and root.hovered == self:
-                    self.is_hovered = True
-                    self.build()
-        return res
-
-
-        
-    def build(self)->None:
-        super().build()
-        if self.is_hovered:
-            hover_surf = Button._cache.get(self.surface.get_size(),None)
-            if hover_surf is None:
-                hover_surf = pygame.Surface(self.surface.get_size()).convert_alpha()
-                hover_surf.fill((30,30,30,0))
-                Button._cache[self.surface.get_size()] = hover_surf
-            self.surface.blit(hover_surf,(0,0),special_flags = pygame.BLEND_ADD)
-
-
-    def apply_contraints(self)->None:
-        super().apply_contraints() 
+from .label import Label
+import batFramework as bf
+from typing import Self, Callable,Any
+from .clickableWidget import ClickableWidget
+
+
+class Button(Label, ClickableWidget):
+    def __init__(self, text: str = "", callback: Callable[[],Any] = None) -> None:
+        super().__init__(text=text)
+        self.set_callback(callback)
+
+    def __str__(self) -> str:
+        return f"Button('{self.text_widget.text}')"
+
+    def get_min_required_size(self):
+        res = super().get_min_required_size()
+        res = res[0],res[1]+self.unpressed_relief
+        return res

batFramework/gui/clickableWidget.py

@@ -0,0 +1,244 @@
+import batFramework as bf
+from typing import Self, Callable, Any
+from .interactiveWidget import InteractiveWidget
+from .shape import Shape
+import pygame
+
+
+class ClickableWidget(Shape, InteractiveWidget):
+    _cache: dict = {}
+
+    def __init__(self, callback: Callable[[],Any] = None, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.callback = callback
+        self.is_pressed: bool = False # the state where the button is being held down (releasing will trigger callback)
+        self.is_enabled: bool = True # 
+        self.hover_cursor = bf.const.DEFAULT_HOVER_CURSOR
+        self.click_cursor = bf.const.DEFAULT_CLICK_CURSOR
+
+        self.click_down_sound = None
+        self.click_up_sound = None
+        self.get_focus_sound = None
+        self.lose_focus_sound = None
+
+        self.pressed_relief: int = 1    # Depth effect height when pressed
+        self.unpressed_relief: int = 2  # Depth effect height when released (default)
+        self.silent_focus: bool = False
+        self.set_debug_color("cyan")
+        self.set_relief(self.unpressed_relief)
+        self.set_click_pass_through(False)
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        res = super().get_min_required_size()
+        res = res[0],res[1]+self.unpressed_relief
+        return res
+
+    def set_unpressed_relief(self, relief: int) -> Self:
+        if relief == self.unpressed_relief:
+            return self
+        self.unpressed_relief = relief
+        self.dirty_shape = True
+        if not self.is_pressed:
+            self.set_relief(relief)
+        return self
+
+    def set_pressed_relief(self, relief: int) -> Self:
+        if relief == self.pressed_relief:
+            return self
+        self.pressed_relief = relief
+        self.dirty_shape = True
+        if self.is_pressed:
+            self.set_relief(relief)
+        return self
+
+    def set_silent_focus(self, value: bool) -> Self:
+        self.silent_focus = value
+        return self
+
+    def set_click_down_sound(self, sound_name: str) -> Self:
+        self.click_down_sound = sound_name
+        return self
+
+    def set_click_up_sound(self, sound_name: str) -> Self:
+        self.click_up_sound = sound_name
+        return self
+
+    def set_get_focus_sound(self, sound_name: str) -> Self:
+        self.get_focus_sound = sound_name
+        return self
+
+    def set_lose_focus_sound(self, sound_name: str) -> Self:
+        self.lose_focus_sound = sound_name
+        return self
+
+    def set_hover_cursor(self, cursor: pygame.Cursor) -> Self:
+        self.hover_cursor = cursor
+        return self
+
+    def set_click_cursor(self, cursor: pygame.Cursor) -> Self:
+        self.click_cursor = cursor
+        return self
+
+    def get_surface_filter(self) -> pygame.Surface | None:
+        size = int(self.rect.w), int(self.rect.h)
+        surface_filter = ClickableWidget._cache.get((size, *self.border_radius), None)
+        if surface_filter is None:
+            # Create a mask from the original surface
+            mask = pygame.mask.from_surface(self.surface, threshold=0)
+
+            silhouette_surface = mask.to_surface(
+                setcolor=(30, 30, 30), unsetcolor=(0, 0, 0)
+            )
+
+            ClickableWidget._cache[(size, *self.border_radius)] = silhouette_surface
+
+            surface_filter = silhouette_surface
+
+        return surface_filter
+
+    def allow_focus_to_self(self) -> bool:
+        return True
+
+    def enable(self) -> Self:
+        self.is_enabled = True
+        self.dirty_surface = True
+        return self
+
+    def disable(self) -> Self:
+        self.is_enabled = False
+        self.dirty_surface = True
+        return self
+
+    def set_callback(self, callback: Callable[[],Any]) -> Self:
+        self.callback = callback
+        return self
+
+    def on_get_focus(self):
+        super().on_get_focus()
+        if self.get_focus_sound and not self.silent_focus:
+            if self.parent_scene and self.parent_scene.visible:
+                bf.AudioManager().play_sound(self.get_focus_sound)
+        if self.silent_focus:
+            self.silent_focus = False
+
+    def on_lose_focus(self):
+        super().on_lose_focus()
+        if self.lose_focus_sound and not self.silent_focus:
+            if self.parent_scene and self.parent_scene.visible:
+                bf.AudioManager().play_sound(self.lose_focus_sound)
+        if self.silent_focus:
+            self.silent_focus = False
+
+    def __str__(self) -> str:
+        return f"ClickableWidget"
+
+    def click(self, force=False) -> None:
+        if not self.is_enabled and not force:
+            return False
+        if self.callback is not None:
+            self.callback()
+            return True
+        return False
+ 
+    def on_key_down(self, key,event):
+        if key == pygame.K_SPACE:
+            self.on_click_down(1,event)
+        self.do_on_key_down(key,event)
+    
+    def on_key_up(self, key,event):
+        if key == pygame.K_SPACE:
+            self.on_click_up(1,event)
+        self.do_on_key_down(key,event)
+
+    def on_click_down(self, button,event) -> None :
+        if button < 1 or button > 5 :
+            return
+        self.is_clicked_down[button-1] = True
+        if button != 1:
+            return        
+        event.consumed = not self.click_pass_through
+        if self.is_enabled and self.get_focus():
+            self.is_pressed = True
+            if self.click_down_sound:
+                bf.AudioManager().play_sound(self.click_down_sound)
+            pygame.mouse.set_cursor(self.click_cursor)
+            self.set_relief(self.pressed_relief)
+            self.do_on_click_down(button,event)
+
+    def on_click_up(self, button,event):
+        if button < 1 or button > 5 :
+            return
+        self.is_clicked_down[button-1] = False
+        if button != 1 :
+            return
+        event.consumed = not self.click_pass_through
+        if self.is_enabled and self.is_pressed:
+            self.is_pressed = False
+            if self.click_up_sound:
+                bf.AudioManager().play_sound(self.click_up_sound)
+            self.set_relief(self.unpressed_relief)
+            self.click()
+            self.do_on_click_up(button,event)
+
+    def on_enter(self) -> None:
+        self.is_hovered = True
+        if not self.is_enabled:
+            return
+        super().on_enter()
+        self.dirty_surface = True
+        pygame.mouse.set_cursor(self.hover_cursor)
+
+    def on_exit(self) -> None:
+        super().on_exit()
+        if self.is_pressed:
+            self.set_relief(self.unpressed_relief)
+        self.is_pressed = False
+        self.dirty_surface = True
+        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
+
+    def on_lose_focus(self):
+        super().on_lose_focus()
+        self.on_exit()
+
+    def _paint_disabled(self) -> None:
+        self.surface.blit(
+            self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_RGB_SUB
+        )
+
+    def _paint_hovered(self) -> None:
+        self.surface.blit(
+            self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_RGB_ADD
+        )
+
+    def get_inner_rect(self) -> pygame.FRect:
+        return pygame.FRect(
+            self.rect.x + self.padding[0],
+            self.rect.y + self.padding[1] + (self.unpressed_relief - self.pressed_relief if self.is_pressed else 0),
+            self.rect.w - self.padding[2] - self.padding[0],
+            self.rect.h - self.unpressed_relief - self.padding[1] - self.padding[3],
+        )
+
+    def get_local_inner_rect(self) -> pygame.FRect:
+        return pygame.FRect(
+            self.padding[0],
+            self.padding[1] + (self.unpressed_relief - self.pressed_relief if self.is_pressed else 0),
+            self.rect.w - self.padding[2] - self.padding[0],
+            self.rect.h - self.unpressed_relief - self.padding[1] - self.padding[3],
+        )
+
+
+    def _get_elevated_rect(self) -> pygame.FRect:
+        return pygame.FRect(
+            0,
+            self.unpressed_relief - self.pressed_relief if self.is_pressed else 0,
+            self.rect.w,
+            self.rect.h - self.unpressed_relief,
+        )
+
+    def paint(self) -> None:
+        super().paint()
+        if not self.is_enabled:
+            self._paint_disabled()
+        elif self.is_hovered:
+            self._paint_hovered()
+ 

batFramework/gui/collapseContainer.py

@@ -0,0 +1,98 @@
+from .container import Container
+from .scrollingContainer import ScrollingContainer
+from .interactiveWidget import InteractiveWidget
+from .toggle import Toggle
+from .shape import Shape
+from .indicator import ArrowIndicator
+from .syncedVar import SyncedVar
+from .layout import Column
+import batFramework as bf
+from .syncedVar import SyncedVar
+from .widget import Widget
+from .layout import Layout
+
+
+class CollapseIndicator(ArrowIndicator):
+    def __init__(self,synced_var:SyncedVar[bool]):
+        super().__init__(bf.direction.RIGHT)
+        synced_var.bind(self,self.on_state_change)
+
+    def on_state_change(self,state:bool):
+        self.set_arrow_direction(bf.direction.DOWN if state else bf.direction.RIGHT)
+
+    def top_at(self, x: float, y: float) -> "None|Widget":
+        r = super().top_at(x, y)
+        if r is self:
+            return None
+        return r
+
+
+class CollapseContainer(Shape,InteractiveWidget):
+    def __init__(self, text:str, layout:Layout=None, *children:Widget, **kwargs):
+        super().__init__(**kwargs)
+        self.state = SyncedVar[bool](False)
+        self.state.bind(self,self._on_state_change)
+        self.toggle = Toggle(text,synced_var=self.state)
+        self.toggle.set_autoresize_w(False)
+        self.container = Container(layout,*children)
+        self.container.set_autoresize_w(False)
+        self.add(self.toggle,self.container)
+        self.state.value = False
+        self.toggle.set_indicator(CollapseIndicator(self.state))
+        self.toggle.indicator.add_constraints(bf.gui.AspectRatio(1,reference_axis=bf.axis.VERTICAL))
+
+    def __str__(self):
+        return "CollapseContainer"
+
+    def _on_state_change(self,value):
+        print("state is ",value)
+        self.container.show() if value else self.container.hide()
+        self.dirty_shape = True
+
+    def allow_focus_to_self(self):
+        return super().allow_focus_to_self() and self.toggle.allow_focus_to_self()
+
+    def get_focus(self):
+        if self.allow_focus_to_self() and ((r := self.get_root()) is not None):
+            r.focus_on(self.toggle)
+            return True
+        return False
+
+    def build(self):
+        res = False
+        min_size = self.get_min_required_size()
+        target_size = self.resolve_size(min_size)
+        if self.rect.size != target_size :
+            self.set_size(target_size)
+            res = True
+
+        inner = self.get_inner_rect()
+        self.toggle.set_size((inner.w,None))
+        self.toggle.set_position(*inner.topleft)
+        if self.state.value:
+            self.container.set_size((inner.w,None))
+            self.container.set_position(*self.toggle.rect.bottomleft)
+        return res
+
+    def apply_updates(self, pass_type):
+
+        if pass_type == "pre":
+            self.apply_pre_updates()
+            if self.state.value : self.container.apply_updates("pre")
+            self.toggle.apply_updates("pre")
+        elif pass_type == "post":
+            if self.state.value : self.container.apply_updates("post")
+            self.toggle.apply_updates("post")
+            self.apply_post_updates(skip_draw=not self.visible)
+
+
+    def get_min_required_size(self):
+        t_min = self.toggle.get_min_required_size()
+        if self.container.layout:
+            c_min = self.container.expand_rect_with_padding((0,0,*self.container.layout.get_raw_size())).size
+        else:
+            c_min = self.container.get_min_required_size()
+        if not self.state.value:
+            c_min = (c_min[0],0)
+        
+        return self.expand_rect_with_padding((0,0,max(t_min[0],c_min[0]),t_min[1]+c_min[1])).size

batFramework/gui/constraints/__init__.py

@@ -0,0 +1 @@
+from . import constraints