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

batFramework/gui/toggle.py

@@ -1,9 +1,8 @@
 from .button import Button
 from .indicator import Indicator, ToggleIndicator
+from .shape import Shape
 import batFramework as bf
 from typing import Self,Callable,Any
-import pygame
-
 
 class Toggle(Button):
     def __init__(self, text: str = "", callback : Callable[[bool],Any]=None, default_value: bool = False) -> None:
@@ -54,57 +53,76 @@ class Toggle(Button):
     def get_min_required_size(self) -> tuple[float, float]:
         if not self.text_rect:
             self.text_rect.size = self._get_text_rect_required_size()
-        size = (
-            max(
-                self.indicator.get_min_required_size()[0],
-                self.text_rect.w + self.font_object.point_size + (self.gap if self.text else 0),
-            ),
-            self.text_rect.h+self.unpressed_relief,
-        )
-        return self.inflate_rect_by_padding((0, 0, *size)).size
 
-    def _build_layout(self) -> None:
+        text_width, text_height = self.text_rect.size
+        indicator_size = self.indicator.get_min_required_size()[1]
         gap = self.gap if self.text else 0
+
+        total_width = text_width + gap + indicator_size
+        total_height = text_height + self.unpressed_relief
+
+        return self.expand_rect_with_padding((0, 0, total_width, total_height)).size
+
+    def _build_composed_layout(self,other:Shape):
+        size_changed = False
         self.text_rect.size = self._get_text_rect_required_size()
 
-        #right part size
-        right_part_height = min(self.text_rect.h, self.font_object.point_size)
-        self.indicator.set_size_if_autoresize((right_part_height,right_part_height))
-
-        #join left and right
-        joined_rect = pygame.FRect(
-            0, 0, self.text_rect.w + gap + self.indicator.rect.w, self.text_rect.h 
-        )
-
-        if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding(joined_rect)
-            target_rect.h += self.unpressed_relief
-            if not self.autoresize_w:
-                target_rect.w = self.rect.w
-            if not self.autoresize_h:
-                target_rect.h = self.rect.h
-            if self.rect.size != target_rect.size:
-                self.set_size(target_rect.size)
-                self.apply_updates()
-
-        # ------------------------------------ size is ok
-
-        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-        padded_rect = self.get_padded_rect()
-        padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
-
-        self.align_text(joined_rect, padded_relative.move( offset), self.alignment)
-        self.text_rect.midleft = joined_rect.midleft
-
-        if self.text:
-            match self.spacing:
-                case bf.spacing.MAX:
-                    gap = padded_relative.right - self.text_rect.right - self.indicator.rect.w
-                case bf.spacing.MIN:
-                    gap = 0
-
-        pos = self.text_rect.move(
-                self.rect.x + gap -offset[0],
-                self.rect.y + (self.text_rect.h / 2) - (right_part_height/ 2) -offset[1],
-            ).topright
-        self.indicator.rect.topleft = pos
+        gap = self.gap if self.text else 0
+        full_rect = self.text_rect.copy()
+
+        other_height = min(self.text_rect.h, self.font_object.get_height()+1)
+        other.set_size(other.resolve_size((other_height,other_height)))
+        
+        full_rect.w += other.rect.w + gap
+        full_rect.h += self.unpressed_relief
+        
+
+        # take into account the relief when calculating target size
+        inflated = self.expand_rect_with_padding((0, 0, *full_rect.size)).size
+        target_size = self.resolve_size(inflated)
+        if self.rect.size != target_size:
+            self.set_size(target_size)
+            size_changed = True
+
+        self._align_composed(other)
+        return size_changed
+
+    def _align_composed(self,other:Shape):
+        
+        full_rect = self.get_local_inner_rect()
+        left_rect = self.text_rect
+        right_rect = other.rect
+        gap = {
+            bf.spacing.MIN: 0,
+            bf.spacing.HALF: (full_rect.width - left_rect.width - right_rect.width) // 2,
+            bf.spacing.MAX: full_rect.width - left_rect.width - right_rect.width,
+            bf.spacing.MANUAL: self.gap
+        }.get(self.spacing, 0)
+
+        gap = max(0, gap)
+        combined_width = left_rect.width + right_rect.width + gap
+
+        group_x = {
+            bf.alignment.LEFT: full_rect.left,
+            bf.alignment.MIDLEFT: full_rect.left,
+            bf.alignment.RIGHT: full_rect.right - combined_width,
+            bf.alignment.MIDRIGHT: full_rect.right - combined_width,
+            bf.alignment.CENTER: full_rect.centerx - combined_width // 2
+        }.get(self.alignment, full_rect.left)
+
+        left_rect.x, right_rect.x = group_x, group_x + left_rect.width + gap
+
+        if self.alignment in {bf.alignment.TOP, bf.alignment.TOPLEFT, bf.alignment.TOPRIGHT}:
+            left_rect.top = right_rect.top = full_rect.top
+        elif self.alignment in {bf.alignment.BOTTOM, bf.alignment.BOTTOMLEFT, bf.alignment.BOTTOMRIGHT}:
+            left_rect.bottom = right_rect.bottom = full_rect.bottom
+        else:
+            left_rect.centery = right_rect.centery = full_rect.centery
+
+        right_rect.move_ip(*self.rect.topleft)
+
+    def _build_layout(self) -> None:
+        return self._build_composed_layout(self.indicator)
+
+
+

batFramework/gui/tooltip.py

@@ -0,0 +1,30 @@
+from .label import Label
+import batFramework as bf
+import sys
+
+class ToolTip(Label):
+    def __init__(self, text = ""):
+        super().__init__(text)
+        self.fade_in_duration : float = 0.1
+        self.fade_out_duration : float = 0.1
+        self.set_render_order(sys.maxsize)
+    
+    def __str__(self):
+        return f"ToolTip('{self.text}')"
+
+    def top_at(self, x, y):
+        return None
+
+    def fade_in(self):
+        self.set_visible(True)
+        bf.PropertyEaser(
+            self.fade_in_duration,bf.easing.EASE_OUT,
+            0,self.parent_scene.name
+        ).add_custom(self.get_alpha,self.set_alpha,255).start()
+
+    def fade_out(self):
+        bf.PropertyEaser(
+            self.fade_out_duration,bf.easing.EASE_IN,
+            0,self.parent_scene.name,
+            lambda : self.set_visible(False)
+        ).add_custom(self.get_alpha,self.set_alpha,0).start()