batframework 1.0.6__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/gui/clickableWidget.py

@@ -0,0 +1,206 @@
+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=0)->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_silent_focus(self,value:bool)->Self:
+        self.silent_focus = value
+        return self
+
+
+    def set_pressed_relief(self,relief:int=0)->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_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
+            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
+            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

batFramework/gui/constraints/constraints.py

@@ -0,0 +1,378 @@
+from ..widget import Widget
+import batFramework as bf
+import pygame
+
+
+class Constraint:
+    def __init__(self, name="Constraint", priority=0):
+        self.priority = priority
+        self.name = name
+
+    def set_priority(self, priority) -> "Constraint":
+        self.priority = priority
+        return self
+
+    def __str__(self) -> str:
+        return f"{self.name.upper()}"
+
+    def evaluate(self, parent_widget: Widget, child_widget: Widget) -> bool:
+        raise NotImplementedError("Subclasses must implement evaluate method")
+
+    def apply(self, parent_widget: Widget, child_widget: Widget = None) -> bool:
+        if not self.evaluate(parent_widget, child_widget):
+            self.apply_constraint(parent_widget, child_widget)
+            return False
+        return True
+
+    def apply_constraint(self, parent_widget: Widget, child_widget: Widget):
+        raise NotImplementedError("Subclasses must implement apply_constraint method")
+
+
+class MinWidth(Constraint):
+    def __init__(self, width: float):
+        super().__init__(name="min_width")
+        self.min_width = width
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.width >= self.min_width
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_size((self.min_width,None))
+
+
+class MinHeight(Constraint):
+    def __init__(self, height: float):
+        super().__init__(name="min_height")
+        self.min_height = height
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.h >= self.min_height
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_size((None, self.min_height))
+
+
+class CenterX(Constraint):
+    def __init__(self):
+        super().__init__(name="centerx")
+
+    def evaluate(self, parent_widget, child_widget):
+        return int(child_widget.rect.centerx - parent_widget.get_padded_center()[0]) == 0 
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_center(
+                parent_widget.get_padded_center()[0], child_widget.rect.centery
+            )
+
+
+class CenterY(Constraint):
+    def __init__(self):
+        super().__init__(name="centery")
+
+    def evaluate(self, parent_widget, child_widget):
+        return int(child_widget.rect.centery - parent_widget.get_padded_center()[1]) == 0 
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_center(
+                child_widget.rect.centerx, parent_widget.get_padded_center()[1]
+            )
+
+
+class Center(Constraint):
+    def __init__(self):
+        super().__init__(name="center")
+
+    def evaluate(self, parent_widget, child_widget):
+        return int(child_widget.rect.centerx - parent_widget.get_padded_center()[0]) == 0 and \
+        int(child_widget.rect.centery - parent_widget.get_padded_center()[1]) == 0
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_center(*parent_widget.get_padded_center())
+
+
+class PercentageWidth(Constraint):
+    def __init__(self, percentage: float, keep_autoresize: bool = False):
+        super().__init__(name="percentage_width")
+        self.percentage: float = percentage
+        self.keep_autoresize: bool = keep_autoresize
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.width == round(
+            parent_widget.get_padded_width() * self.percentage
+        )
+
+    def apply_constraint(self, parent_widget, child_widget):
+        if child_widget.autoresize_w:
+            if self.keep_autoresize:
+                print(
+                    f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                )
+                return
+            child_widget.set_autoresize_w(False)
+
+        child_widget.set_size(
+            (
+                round(parent_widget.get_padded_width() * self.percentage),None)
+        )
+
+class PercentageHeight(Constraint):
+    def __init__(self, percentage: float, keep_autoresize: bool = False):
+        super().__init__(name="percentage_height")
+        self.percentage: float = percentage
+        self.keep_autoresize: bool = keep_autoresize
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.height == round(parent_widget.get_padded_height() * self.percentage)
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
+
+    def apply_constraint(self, parent_widget, child_widget):
+        if child_widget.autoresize_h:
+            if self.keep_autoresize:
+                print(f"WARNING: Constraint on {child_widget} can't resize, autoresize set to True")
+                return
+            child_widget.set_autoresize_h(False)
+        child_widget.set_size((None,round(parent_widget.get_padded_height() * self.percentage)))
+
+class FillX(PercentageWidth):
+    def __init__(self, keep_autoresize: bool = False):
+        super().__init__(1,keep_autoresize)
+        self.name = "fill_x"
+
+class FillY(PercentageHeight):
+    def __init__(self, keep_autoresize: bool = False):
+        super().__init__(1,keep_autoresize)
+        self.name = "fill_y"
+
+
+class Height(Constraint):
+    def __init__(self, height: float, keep_autoresize: bool = False):
+        if height < 0:
+            raise ValueError("height can't be negative")
+        super().__init__(name="height")
+        self.height = height
+        self.keep_autoresize: bool = keep_autoresize
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}.(height={self.height})"
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.height == self.height
+
+    def apply_constraint(self, parent_widget, child_widget):
+        if child_widget.autoresize_h:
+            if self.keep_autoresize:
+                print(f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True")
+                return
+            child_widget.set_autoresize_h(False)
+        child_widget.set_size((None, self.height))
+
+
+class Width(Constraint):
+    def __init__(self, width: float, keep_autoresize: bool = False):
+        if width < 0:
+            raise ValueError("width can't be negative")
+        super().__init__(name="width")
+        self.width = width
+        self.keep_autoresize: bool = keep_autoresize
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}.(width={self.width})"
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.width == self.width
+
+    def apply_constraint(self, parent_widget, child_widget):
+        if child_widget.autoresize_w:
+            if self.keep_autoresize:
+                print(
+                    f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                )
+                return
+            child_widget.set_autoresize_w(False)
+        child_widget.set_size((self.width, None))
+
+
+class AspectRatio(Constraint):
+    def __init__(
+        self,
+        ratio: int | float | pygame.rect.FRectType = 1,
+        reference_axis: bf.axis = bf.axis.HORIZONTAL,
+        keep_autoresize=False,
+    ):
+        super().__init__(name="aspect_ratio")
+        self.ref_axis : bf.axis = reference_axis
+        self.keep_autoresize: bool = keep_autoresize
+
+        if isinstance(ratio, float | int):
+            self.ratio = ratio
+        elif isinstance(ratio, pygame.rect.FRect):
+            self.ratio = (ratio.w / ratio.h) if reference_axis == bf.axis.HORIZONTAL else (ratio.h / ratio.w)
+        else:
+            raise TypeError(f"Ratio must be float or FRect")
+
+    def evaluate(self, parent_widget, child_widget):
+        if self.ref_axis == bf.axis.HORIZONTAL:
+            return self.ratio == child_widget.rect.w / child_widget.rect.h
+        if self.ref_axis == bf.axis.VERTICAL:
+            return self.ratio == child_widget.rect.h / child_widget.rect.w
+
+    def apply_constraint(self, parent_widget, child_widget):
+
+        if self.ref_axis == bf.axis.VERTICAL:
+            if child_widget.autoresize_w :
+                if self.keep_autoresize:
+                    print(
+                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                    )
+                    return
+                child_widget.set_autoresize_w(False)
+            child_widget.set_size((child_widget.rect.h * self.ratio,None))
+        
+        if self.ref_axis == bf.axis.HORIZONTAL:
+            if child_widget.autoresize_h :
+                if self.keep_autoresize:
+                    print(
+                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                    )
+                    return
+                child_widget.set_autoresize_h(False)
+            print("HERE")
+            child_widget.set_size((None,child_widget.rect.w * self.ratio))
+
+class AnchorBottom(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_bottom")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.top == parent_widget.get_padded_bottom() - child_widget.rect.h
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(child_widget.rect.x,parent_widget.get_padded_bottom() - child_widget.rect.h)
+
+class AnchorBottom(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_bottom")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.top == parent_widget.get_padded_bottom() - child_widget.rect.h
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(child_widget.rect.x,parent_widget.get_padded_bottom() - child_widget.rect.h)
+
+
+
+class AnchorTopRight(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_topright")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.topright == parent_widget.get_padded_rect().topright
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.get_padded_right() - child_widget.rect.w,
+            parent_widget.get_padded_top(),
+        )
+
+
+class AnchorBottomRight(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_bottomright")
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.bottomright == parent_widget.get_padded_rect().bottomright
+        )
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.get_padded_right() - child_widget.rect.w,
+            parent_widget.get_padded_bottom() - child_widget.rect.h,
+        )
+
+
+class AnchorRight(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_right")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.right == parent_widget.get_padded_right()
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.get_padded_right() - child_widget.rect.w,
+            child_widget.rect.top,
+        )
+
+
+class AnchorLeft(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_left")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.left == parent_widget.get_padded_left()
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.get_padded_left(), child_widget.rect.top
+        )
+
+
+class MarginBottom(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="margin_bottom")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.bottom == parent_widget.get_padded_bottom() - self.margin
+        )
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(child_widget.rect.x,
+            parent_widget.get_padded_bottom() - child_widget.rect.h - self.margin
+        )
+
+class MarginTop(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="margin_top")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.top == parent_widget.get_padded_top() + self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(child_widget.rect.x,parent_widget.get_padded_top() + self.margin)
+
+
+class MarginLeft(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="margin_left")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.left == parent_widget.get_padded_left() + self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        if not self.evaluate(parent_widget, child_widget):
+            child_widget.set_position(parent_widget.get_padded_left() + self.margin,child_widget.rect.y)
+
+
+class MarginRight(Constraint):
+    def __init__(self, margin: float):
+        super().__init__(name="margin_right")
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.right == parent_widget.get_padded_right() - self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.get_padded_right() - child_widget.rect.w - self.margin,
+            child_widget.rect.y
+        )