batframework 1.0.8a9__py3-none-any.whl → 1.0.8a10__py3-none-any.whl

batFramework/gui/button.py

@@ -1,84 +1,15 @@
 from .label import Label
 import batFramework as bf
-from types import FunctionType
-from typing import Self
-from .interactiveWidget import InteractiveWidget
+from typing import Self, Callable
+from .clickableWidget import ClickableWidget
 import pygame
+from math import ceil
 
-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)
 
+class Button(Label, ClickableWidget):
+    def __init__(self, text: str = "", callback: None | Callable = None) -> None:
+        super().__init__(text=text)
+        self.set_callback(callback)
 
-    def apply_contraints(self)->None:
-        super().apply_contraints() 
+    def __str__(self) -> str:
+        return f"Button({self.text})"

batFramework/gui/clickableWidget.py

@@ -0,0 +1,220 @@
+from .label import Label
+import batFramework as bf
+from typing import Self, Callable
+from .interactiveWidget import InteractiveWidget
+from .shape import Shape
+import pygame
+from math import ceil
+
+
+class ClickableWidget(Shape, InteractiveWidget):
+    _cache: dict = {}
+
+    def __init__(self, callback: None | Callable = None, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.callback = callback
+        self.is_pressed: bool = False
+        self.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
+        self.unpressed_relief: int = 2
+        self.silent_focus: bool = False
+        self.set_debug_color("cyan")
+        self.set_relief(self.unpressed_relief)
+
+    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.enabled = True
+        self.dirty_surface = True
+        return self
+
+    def disable(self) -> Self:
+        self.enabled = False
+        self.dirty_surface = True
+        return self
+
+    def is_enabled(self) -> bool:
+        return self.enabled
+
+    def set_callback(self, callback: Callable) -> 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.enabled and not force:
+            return
+        if self.callback is not None:
+            self.callback()
+
+    def do_on_click_down(self, button) -> None:
+        if self.enabled and button == 1:
+            if not self.get_focus():
+                return
+            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)
+
+    def do_on_click_up(self, button) -> None:
+        if self.enabled and button == 1 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()
+
+    def on_enter(self) -> None:
+        if not self.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 on_key_down(self, key):
+        if key == pygame.K_SPACE:
+            self.on_click_down(1)
+        super().on_key_down(key)
+
+    def on_key_up(self, key):
+        if key == pygame.K_SPACE:
+            self.on_click_up(1)
+        super().on_key_up(key)
+
+    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_padded_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_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.enabled:
+            self._paint_disabled()
+        elif self.is_hovered:
+            self._paint_hovered()
+ 

batFramework/gui/constraints/__init__.py

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