batframework 1.0.9a6__py3-none-any.whl → 1.0.9a8__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):
+
+        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)
+
+        self._align_composed(other)
+        
+
+    def _align_composed(self,other:Shape):
+        
+        full_rect = self.get_local_padded_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:
         self.text_rect.size = self._get_text_rect_required_size()
+        self._build_composed_layout(self.indicator)
+
 
-        #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

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()

batFramework/gui/widget.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Self, Callable
+from typing import TYPE_CHECKING, Self, Callable, Any
 from collections.abc import Iterable
 import batFramework as bf
 import pygame
@@ -6,13 +6,13 @@ import pygame
 if TYPE_CHECKING:
     from .constraints.constraints import Constraint
     from .root import Root
-MAX_CONSTRAINTS = 10
 
+MAX_ITERATIONS = 10
 
 class WidgetMeta(type):
     def __call__(cls, *args, **kwargs):
         obj = type.__call__(cls, *args, **kwargs)
-        bf.StyleManager().register_widget(obj)
+        bf.gui.StyleManager().register_widget(obj)
         return obj
 
 
@@ -25,15 +25,21 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         self.do_sort_children = False
         self.clip_children: bool = True
         self.padding = (0, 0, 0, 0)
-        self.dirty_surface: bool = True  #  if true will call paint before drawing
-        self.dirty_shape: bool = True  #    if true will call (build+paint) before drawing
-        self.dirty_constraints: bool = False # if true will call resolve_constraints
+        self.dirty_surface: bool = True  # If true, will call paint before drawing
+        self.dirty_shape: bool = True  # If true, will call (build+paint) before drawing
+        self.dirty_position_constraints: bool = True  # Flag for position-related constraints
+        self.dirty_size_constraints: bool = True  # Flag for size-related constraints
 
+        self.tooltip_text: str | None = None  # If not None, will display a text when hovered
         self.is_root: bool = False
-        self.autoresize_w, self.autoresize_h = True, True
-        self.__constraint_iteration = 0
-        self.__constraints_to_ignore = []
-        self.__constraints_capture = None
+        self.autoresize_w, self.autoresize_h = True, True  # If True, the widget will have dynamic size depending on its contents
+        self._constraint_iteration = 0
+        self._constraints_to_ignore: list[Constraint] = []
+        self._constraints_capture: list[Constraint] = []
+
+    def set_tooltip_text(self,text:str|None)->Self:
+        self.tooltip_text = text
+        return self
 
     def show(self) -> Self:
         self.visit(lambda w: w.set_visible(True))
@@ -43,6 +49,14 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         self.visit(lambda w: w.set_visible(False))
         return self
 
+    def kill(self):
+        if self.parent:
+            self.parent.remove(self)
+        if self.parent_scene:
+            self.parent_scene.remove(self.parent_layer.name,self)
+            
+        return super().kill()
+
     def set_clip_children(self, value: bool) -> Self:
         self.clip_children = value
         self.dirty_surface = True
@@ -72,7 +86,7 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
             self.parent.do_sort_children = True
         return self
 
-    def inflate_rect_by_padding(
+    def expand_rect_with_padding(
         self, rect: pygame.Rect | pygame.FRect
     ) -> pygame.Rect | pygame.FRect:
         return pygame.FRect(
@@ -112,12 +126,18 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
     def set_parent_scene(self, parent_scene: bf.Scene | None) -> Self:
         super().set_parent_scene(parent_scene)
         if parent_scene is None:
-            bf.StyleManager().remove_widget(self)
+            bf.gui.StyleManager().remove_widget(self)
 
         for c in self.children:
             c.set_parent_scene(parent_scene)
         return self
 
+    def set_parent_layer(self, layer):
+        super().set_parent_layer(layer)
+        for c in self.children:
+            c.set_parent_layer(layer)
+        return self
+
     def set_parent(self, parent: "Widget") -> Self:
         if parent == self.parent:
             return self
@@ -142,7 +162,7 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         self.dirty_shape = True
         return self
 
-    def get_padded_rect(self) -> pygame.FRect:
+    def get_inner_rect(self) -> pygame.FRect:
         r = self.rect.inflate(
             -self.padding[0] - self.padding[2], -self.padding[1] - self.padding[3]
         )
@@ -152,33 +172,33 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
     def get_min_required_size(self) -> tuple[float, float]:
         return self.rect.size
 
-    def get_padded_width(self) -> float:
+    def get_inner_width(self) -> float:
         return self.rect.w - self.padding[0] - self.padding[2]
 
-    def get_padded_height(self) -> float:
+    def get_inner_height(self) -> float:
         return self.rect.h - self.padding[1] - self.padding[3]
 
-    def get_padded_left(self) -> float:
+    def get_inner_left(self) -> float:
         return self.rect.left + self.padding[0]
 
-    def get_padded_right(self) -> float:
-        return self.rect.right + self.padding[2]
+    def get_inner_right(self) -> float:
+        return self.rect.right - self.padding[2]
 
-    def get_padded_center(self) -> tuple[float, float]:
-        return self.get_padded_rect().center
+    def get_inner_center(self) -> tuple[float, float]:
+        return self.get_inner_rect().center
 
-    def get_padded_top(self) -> float:
+    def get_inner_top(self) -> float:
         return self.rect.y + self.padding[1]
 
-    def get_padded_bottom(self) -> float:
+    def get_inner_bottom(self) -> float:
         return self.rect.bottom - self.padding[3]
 
     def get_debug_outlines(self):
         if self.visible:
             if any(self.padding):
-                yield (self.get_padded_rect(), self.debug_color)
-            else:
-                yield (self.rect, self.debug_color)
+                yield (self.get_inner_rect(), self.debug_color)
+            # else:
+            yield (self.rect, self.debug_color)
         for child in self.children:
             yield from child.get_debug_outlines()
 
@@ -192,8 +212,12 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
                 seen.add(c.name)
         self.constraints = result
         self.constraints.sort(key=lambda c: c.priority)
-        self.dirty_constraints = True
-        self.__constraint_to_ignore = []
+        size_c = any(c.affects_size for c in constraints)
+        position_c = any(c.affects_position for c in constraints)
+        if position_c : self.dirty_position_constraints = True
+        if size_c : self.dirty_size_constraints = True
+        
+        self._constraints_to_ignore = []
 
         return self
 
@@ -203,60 +227,86 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
             if c.name in names:
                 c.on_removal(self)
         self.constraints = [c for c in self.constraints if c.name not in names]
-        self.__constraint_to_ignore = []
+        self._constraints_to_ignore = []
         return self
 
-    def resolve_constraints(self) -> None:
+
+    def resolve_constraints(self, size_only: bool = False, position_only: bool = False) -> None:
+        """
+        Resolve constraints affecting size and/or position independently.
+
+        This system attempts to apply constraints iteratively until a stable solution is found,
+        or until MAX_ITERATIONS is reached.
+        """
         if self.parent is None or not self.constraints:
-            self.dirty_constraints = False
+            if size_only:
+                self.dirty_size_constraints = False
+            if position_only:
+                self.dirty_position_constraints = False
             return
 
-        if not self.__constraint_iteration:
-            self.__constraints_capture = None
+        # If not currently resolving constraints, reset tracking lists
+        if not self._constraint_iteration:
+            self._constraints_capture = []
         else:
-            capture = tuple([c.priority for c in self.constraints])
-            if capture != self.__constraints_capture:
-                self.__constraints_capture = capture
-                self.__constraint_to_ignore = []
-                
-        constraints = self.constraints.copy()
-        # If all are resolved early exit
-        if all(c.evaluate(self.parent,self) for c in constraints if c not in self.__constraint_to_ignore):
-            self.dirty_constraints = False
-            return
-        
-        # # Here there might be a conflict between 2 or more constraints
-        # we have to determine which ones causes conflict and ignore the one with least priority
-
-        stop = False
-
-        while True:
-            stop = True
-            # first pass with 2 iterations to sort out the transformative constraints
-            for _ in range(2):
-                for c in constraints:
-                    if c in self.__constraints_to_ignore:continue
-                    if not c.evaluate(self.parent,self) :
-                        # print(c," is applied")
-                        c.apply(self.parent,self)
-            # second pass where we check conflicts
-            for c in constraints:
-                if c in self.__constraints_to_ignore:
-                    continue
-                if not c.evaluate(self.parent,self):
-                    # first pass invalidated this constraint
-                    self.__constraints_to_ignore.append(c)
-                    stop = False
-                    break
-
-            if stop: 
-                break
+            # Detect constraint priority changes since last resolution
+            current_priorities = [c.priority for c in self.constraints]
+            if current_priorities != self._constraints_capture:
+                self._constraints_capture = current_priorities
+                self._constraints_to_ignore = []
+
+        # Filter constraints based on what needs resolving
+        def is_relevant(c: "Constraint") -> bool:
+            return (
+                c.affects_size if size_only else
+                c.affects_position if position_only else
+                True
+            )
 
-        if self.__constraints_to_ignore:
-            print("Constraints ignored : ",[str(c) for c in self.__constraints_to_ignore])
-            
-        self.dirty_constraints = False
-        # print(self,self.uid,"resolve constraints : Success")
+        active_constraints = [c for c in self.constraints if is_relevant(c)]
+        active_constraints.sort(key=lambda c: c.priority, reverse=True)
+
+        resolved = []
+        for iteration in range(MAX_ITERATIONS):
+            self._constraint_iteration += 1
+            changed = False
+
+            for constraint in active_constraints:
+                if constraint in resolved:
+                    # Re-evaluate to confirm the constraint is still satisfied
+                    if not constraint.evaluate(self.parent, self):
+                        resolved.remove(constraint)
+                        changed = True
+                else:
+                    # Try applying unresolved constraint
+                    if constraint.apply(self.parent, self):
+                        resolved.append(constraint)
+                        changed = True
+
+            if not changed:
+                break  # All constraints stable — done
+
+        # If solution is still unstable, record the unresolved ones
+        if self._constraint_iteration >= MAX_ITERATIONS:
+            self._constraints_to_ignore += [
+                c for c in active_constraints if c not in resolved
+            ]
+
+        # Record final resolved constraints for debugging/tracking
+        self._constraints_capture.clear()
+        self._constraints_capture.extend(
+            (c, self._constraint_iteration) for c in resolved
+        )
+
+        # Clear appropriate dirty flags
+        if size_only:
+            self.dirty_size_constraints = False
+        if position_only:
+            self.dirty_position_constraints = False
+
+        # Debug print for ignored constraints
+        # if self._constraints_to_ignore:
+            # print(f"{self} ignored constraints: {[str(c) for c in self._constraints_to_ignore]}")
 
 
     def has_constraint(self, name: str) -> bool:
@@ -272,39 +322,41 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
         if self.children:
             for child in reversed(self.children):
-                # if child.visible:
-                r = child.top_at(x, y)
-                if r is not None:
-                    return r
-        return self if  self.rect.collidepoint(x, y) else None
+                if child.visible:
+                    r = child.top_at(x, y)
+                    if r is not None:
+                        return r
+        return self if self.visible and self.rect.collidepoint(x, y) else None
 
     def add(self, *children: "Widget") -> Self:
         self.children.extend(children)
         i = len(self.children)
         for child in children:
-
-            child.set_render_order(i).set_parent(self).set_parent_scene(
-                self.parent_scene
-            )
+            if child.render_order == 0:
+                child.set_render_order(i+1)
+            child.set_parent(self)
+            child.set_parent_layer(self.parent_layer)
+            child.set_parent_scene(self.parent_scene)
             i += 1
         if self.parent:
             self.parent.do_sort_children = True
         return self
 
     def remove(self, *children: "Widget") -> Self:
-        for child in self.children:
+        for child in self.children.copy():
             if child in children:
-                child.set_parent(None).set_parent_scene(None)
+                child.set_parent(None)
+                child.set_parent_scene(None)
+                child.set_parent_layer(None)
                 self.children.remove(child)
         if self.parent:
             self.parent.do_sort_children = True
 
-    def set_size_if_autoresize(self, size: tuple[float, float]) -> Self:
-        size = list(size)
-        size[0] = size[0] if self.autoresize_w else None
-        size[1] = size[1] if self.autoresize_h else None
-        self.set_size(size)
-        return self
+    def resolve_size(self, target_size):
+        return (
+            target_size[0] if self.autoresize_w else self.rect.w,
+            target_size[1] if self.autoresize_h else self.rect.h
+        )
 
     def set_size(self, size: tuple) -> Self:
         size = list(size)
@@ -312,8 +364,7 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
             size[0] = self.rect.w
         if size[1] is None:
             size[1] = self.rect.h
-        if (int(size[0]),int(size[1])) == (int(self.rect.w),int(self.rect.h)):
-            return self
+        if size[0] == self.rect.w and size[1] == self.rect.h : return self
         self.rect.size = size
         self.dirty_shape = True
         return self
@@ -331,21 +382,28 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         _ = [c.update(dt) for c in self.children]
         super().update(dt)
 
-    def build(self) -> None:
+    def build(self) -> bool:
+        """
+        Updates the size of the widget.
+        return True if size changed
+        """
         new_size = tuple(map(int, self.rect.size))
-        if self.surface.get_size() != new_size:
-            old_alpha = self.surface.get_alpha()
-            new_size = [max(0, i) for i in new_size]
-            self.surface = pygame.Surface(new_size, self.surface_flags)
-            if self.convert_alpha:
-                self.surface = self.surface.convert_alpha()
-            self.surface.set_alpha(old_alpha)
+        if self.surface.size == new_size:
+            return False
+        
+        old_alpha = self.surface.get_alpha()
+        new_size = [max(0, i) for i in new_size]
+        self.surface = pygame.Surface(new_size, self.surface_flags)
+        if self.convert_alpha:
+            self.surface = self.surface.convert_alpha()
+        self.surface.set_alpha(old_alpha)
+        return True
 
     def paint(self) -> None:
         self.surface.fill((0, 0, 0, 0))
         return self
 
-    def visit(self, func: Callable, top_down: bool = True, *args, **kwargs) -> None:
+    def visit(self, func: Callable[["Widget"],Any], top_down: bool = True, *args, **kwargs) -> None:
         if top_down:
             func(self, *args, **kwargs)
         for child in self.children:
@@ -378,7 +436,7 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         w = self
         tmp = w
         while not tmp.is_root:
-            if tmp.dirty_constraints or tmp.dirty_shape:
+            if tmp.dirty_size_constraints or tmp.dirty_shape:
                 w = tmp
             if not tmp.parent:
                 break
@@ -386,49 +444,69 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         return w
 
 
-    def apply_updates(self) -> None:
-
-        if self.dirty_constraints:
-            self.resolve_constraints()  # Finalize positioning based on final size
-            self.dirty_constraints = False
+    def apply_updates(self,pass_type):
+        # print(f"Apply updates {pass_type} called on {self}")
+        if pass_type == "pre":
+            self.apply_pre_updates()
+            for child in self.children:
+                child.apply_updates("pre")
+        elif pass_type == "post":
+            for child in self.children:
+                child.apply_updates("post")
+            self.apply_post_updates()
+
+    def apply_pre_updates(self):
+        """
+        TOP TO BOTTOM
+        Resolves size-related constraints before propagating updates to children.
+        """
+        if self.dirty_size_constraints:
+            self.resolve_constraints(size_only=True)
+            self.dirty_size_constraints = False
+            self.dirty_position_constraints = True
+
+    def apply_post_updates(self, skip_draw: bool = False):
+        """
+        BOTTOM TO TOP
+        Resolves position-related constraints after propagating updates from children.
+        """
 
-        # Build shape if needed
         if self.dirty_shape:
-            self.build()  # Finalize widget size
+            
+            if self.build():
+                self.dirty_size_constraints = True
+                self.dirty_position_constraints = True
+                if self.parent :
+                # trigger layout or constraint updates in parent
+                    from .container import Container
+                    if self.parent and isinstance(self.parent, Container):
+                        self.parent.dirty_layout = True
+                        self.parent.dirty_shape = True
             self.dirty_shape = False
             self.dirty_surface = True
-            self.dirty_constraints = True
-            # Propagate dirty_constraints to children in case size affects their position
-            for child in self.children:
-                child.dirty_constraints = True
 
-        # Resolve constraints now that size is finalized
-        if self.dirty_constraints:
-            self.resolve_constraints()  # Finalize positioning based on final size
-            self.dirty_constraints = False
 
+        if self.dirty_position_constraints:
+            self.resolve_constraints(position_only=True)
 
-        # Step 3: Paint the surface if flagged as dirty
-        if self.dirty_surface:
+        if self.dirty_surface and not skip_draw:
             self.paint()
             self.dirty_surface = False
-    
 
 
     def draw(self, camera: bf.Camera) -> None:
-        self.apply_updates()
         # Draw widget and handle clipping if necessary
         super().draw(camera)
 
         if self.clip_children:
-            new_clip = camera.world_to_screen(self.get_padded_rect())
+            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 sorted(self.children, key=lambda c: c.render_order):
-            child.draw(camera)
-
+            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)