batframework 1.0.8a7__py3-none-any.whl → 1.0.8a8__py3-none-any.whl

batFramework/gui/widget.py

@@ -1,415 +1,307 @@
-from typing import TYPE_CHECKING, Self, Callable
-from collections.abc import Iterable
-import batFramework as bf
-import pygame
-
+from __future__ import annotations
+from typing import TYPE_CHECKING
 if TYPE_CHECKING:
-    from .constraints.constraints import Constraint
+    from .constraints import Constraint
     from .root import Root
-MAX_CONSTRAINTS = 10
-
-
-class WidgetMeta(type):
-    def __call__(cls, *args, **kwargs):
-        """Called when you call MyNewClass()"""
-        obj = type.__call__(cls, *args, **kwargs)
-        # obj.new_init()
-        bf.StyleManager().register_widget(obj)
-        return obj
-
-
-class Widget(bf.Entity, metaclass=WidgetMeta):
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.children: list["Widget"] = []
-        self.constraints: list[Constraint] = []
-        self.parent: "Widget" = None
-        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
-        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
-
-    def show(self) -> Self:
-        self.visit(lambda w: w.set_visible(True))
-        return self
+from typing import Self
 
-    def hide(self) -> Self:
-        self.visit(lambda w: w.set_visible(False))
-        return self
+import batFramework as bf
+import pygame
+from math import ceil
+
+
+
+class Widget(bf.Entity):
+    def __init__(self,convert_alpha=True)->None:
+        super().__init__(convert_alpha=convert_alpha)
+        self.autoresize = False
+        self.parent : None|Self = None 
+        self.is_root :bool = False
+        self.children : list["Widget"] = []
+        self.focusable :bool= False
+        self.constraints : list[Constraint] = []
+        self.gui_depth : int = 0
+        if self.surface : self.surface.fill("white")
+        self.set_debug_color("red")
+        self.padding :tuple[float|int,...]= (0,0,0,0) 
+
+    def set_padding(self,value : float|int|tuple|list)->Self:
+        old_raw_size = (
+            self.rect.w - self.padding[0] - self.padding[2],
+            self.rect.h - self.padding[1] - self.padding[3]
+        )
+        if isinstance(value,list) or isinstance(value,tuple):
+            if len(value) > 4 : return self
+            if any(v<0 for v in value) : return self
+            if len(value) == 2:
+                self.padding = (value[0],value[1],value[0],value[1])
+            else:
+                self.padding = (*value, *self.padding[len(value):])
+        else:
+            self.padding = (value,)*4
 
-    def set_clip_children(self, value: bool) -> Self:
-        self.clip_children = value
-        self.dirty_surface = True
+        self.set_size(
+            old_raw_size[0] + self.padding[0] +  self.padding[2],
+            old_raw_size[1] + self.padding[1] +  self.padding[3],
+        )
         return self
+        
+    def inflate_rect_by_padding(self,rect:pygame.FRect)->pygame.FRect:
+        return pygame.FRect(
+            rect[0] - self.padding[0],
+            rect[1]  - self.padding[1],
+            rect[2] + self.padding[0]+self.padding[2],
+            rect[3] + self.padding[1]+self.padding[3]   
+        )
+    def get_content_left(self)->float:
+        return self.rect.left + self.padding[0]
 
-    def __str__(self) -> str:
-        return "Widget"
+    def get_content_top(self)->float:
+        return self.rect.top + self.padding[1]
 
-    def set_autoresize(self, value: bool) -> Self:
-        self.autoresize_w = self.autoresize_h = value
-        self.dirty_shape = True
-        return self
+    def get_content_right(self)->float:
+        return self.rect.right - self.padding[2]
 
-    def set_autoresize_w(self, value: bool) -> Self:
-        self.autoresize_w = value
-        self.dirty_shape = True
-        return self
+    def get_content_bottom(self)->float:
+        return self.rect.bottom - self.padding[3]
 
-    def set_autoresize_h(self, value: bool) -> Self:
-        self.autoresize_h = value
-        self.dirty_shape = True
-        return self
+    def get_content_width(self)->float:
+        return self.rect.w - self.padding[0] - self.padding[2]
 
-    def set_render_order(self, render_order: int) -> Self:
-        super().set_render_order(render_order)
-        if self.parent:
-            self.parent.do_sort_children = True
-        return self
+    def get_content_height(self)->float:
+        return self.rect.h - self.padding[1] - self.padding[3]
 
-    def inflate_rect_by_padding(
-        self, rect: pygame.Rect | pygame.FRect
-    ) -> pygame.Rect | pygame.FRect:
+    def get_content_rect(self)->pygame.FRect:
         return pygame.FRect(
-            rect[0] - self.padding[0],
-            rect[1] - self.padding[1],
-            rect[2] + self.padding[0] + self.padding[2],
-            rect[3] + self.padding[1] + self.padding[3],
+            self.rect.left      + self.padding[0],
+            self.rect.top       + self.padding[1],
+            self.get_content_width(),
+            self.get_content_height()
         )
 
-    def set_position(self, x, y) -> Self:
-        if x is None:
-            x = self.rect.x
-        if y is None:
-            y = self.rect.y
-        if (x, y) == self.rect.topleft:
-            return self
-        dx, dy = x - self.rect.x, y - self.rect.y
-        self.rect.topleft = x, y
-        _ = [c.set_position(c.rect.x + dx, c.rect.y + dy) for c in self.children]
-        return self
-
-    def set_center(self, x, y) -> Self:
-        if x is None:
-            x = self.rect.centerx
-        if y is None:
-            y = self.rect.centery
-        if (x, y) == self.rect.center:
-            return self
-        dx, dy = x - self.rect.centerx, y - self.rect.centery
-        self.rect.center = x, y
-        _ = [
-            c.set_center(c.rect.centerx + dx, c.rect.centery + dy)
-            for c in self.children
-        ]
-        return self
+    def get_content_rect_rel(self)->pygame.FRect:
+        return self.get_content_rect().move(-self.rect.left,-self.rect.top)
 
-    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)
+    def get_content_center(self)->tuple[float,float]:
+        return self.get_content_rect().center
 
-        for c in self.children:
-            c.set_parent_scene(parent_scene)
-        return self
+    def get_depth(self)->int:
+        if self.is_root or self.parent is None : 
+            self.gui_depth = 0
+        else:
+            self.gui_depth =  self.parent.get_depth() + 1
+        return self.gui_depth
 
-    def set_parent(self, parent: "Widget") -> Self:
-        if parent == self.parent:
+    def top_at(self, x: float, y: float) -> "None|Widget":
+        if self.children:
+            for child in reversed(self.children):
+                r = child.top_at(x,y)
+                if r is not None:
+                    return r
+        if self.rect.collidepoint(x,y) and self.visible:
             return self
-        # if self.parent is not None and self.parent != parent:
-        #     self.parent.remove(self)
-        self.parent = parent
+        return None
+            
+    def get_constraint(self,name:str)->Constraint|None:
+        return next((c for c in self.constraints if c.name == name), None)
+
+    def add_constraints(self,*constraints:Constraint)->Self:
+        for c in constraints:
+            self.add_constraint(c,False)
+        self.apply_constraints()
         return self
-
-    def set_padding(self, value: float | int | tuple | list) -> Self:
-        if isinstance(value, Iterable):
-            if len(value) > 4:
-                pass
-            elif any(v < 0 for v in value):
-                pass
-            elif len(value) == 2:
-                self.padding = (value[0], value[1], value[0], value[1])
-            else:
-                self.padding = (*value, *self.padding[len(value) :])
-        else:
-            self.padding = (value,) * 4
-
-        self.dirty_shape = True
+        
+    def add_constraint(self,constraint:Constraint,apply:bool=True)->Self:
+        c = self.get_constraint(constraint.name)
+        if c is not None:
+            self.constraints.remove(c)
+        self.constraints.append(constraint)
+        self.apply_constraints()
         return self
 
-    def get_padded_rect(self) -> pygame.FRect:
-        r = self.rect.inflate(
-            -self.padding[0] - self.padding[2], -self.padding[1] - self.padding[3]
-        )
-        # r.normalize()
-        return r
+    def has_constraint(self,name:str)->bool:
+        return any(c.name == name for c in self.constraints)
 
-    def get_min_required_size(self) -> tuple[float, float]:
-        return self.rect.size
+    def apply_all_constraints(self)->None:
+        # print("APPLY ALL CONSTRAINTS IN ",self.to_string())
+        self.apply_constraints()
+        for child in self.children : child.apply_all_constraints()
+    
+    def apply_constraints(self, max_iterations: int = 10) -> None:
+        if not self.parent:
+            # print(f"Warning : can't apply constraints on {self.to_string()} without parent widget")
+            return
+        if not self.constraints:
+            return
+        # Sort constraints based on priority
+        self.constraints.sort(key=lambda c: c.priority)
 
-    def get_padded_width(self) -> float:
-        return self.rect.w - self.padding[0] - self.padding[2]
+        for iteration in range(max_iterations):
+            unsatisfied = []  # Initialize a flag
 
-    def get_padded_height(self) -> float:
-        return self.rect.h - self.padding[1] - self.padding[3]
+            for constraint in self.constraints:
+                if not constraint.evaluate(self.parent, self):
+                    unsatisfied.append(constraint)
+                    constraint.apply(self.parent, self)
+            if not unsatisfied:
+            #     data = ''.join(f"\n\t->{c.to_string()}" for c in self.constraints)
+            #     print(self.get_depth()*'\t'+f"Following constraints of {self.to_string()} were all satisfied :{data}")
+                break
+            # print(f"pass {iteration}/{max_iterations} : unsatisfied = {';'.join(c.to_string() for c in unsatisfied)}")
+            if iteration == max_iterations - 1:
+                raise ValueError(f"[WARNING] Following constraints for {self.to_string()} were not satisfied : \n\t{';'.join([c.to_string() for c in unsatisfied])}")
 
-    def get_padded_left(self) -> float:
-        return self.rect.left + self.padding[0]
+    # GETTERS
+    def get_root(self)-> Self|Root|None:
+        if self.is_root: return self
+        if self.parent_scene is not None : return self.parent_scene.root
+        return None if self.parent is None else self.parent.get_root()
 
-    def get_padded_right(self) -> float:
-        return self.rect.right + self.padding[2]
+    def get_size_int(self)->tuple[int,int]:
+        return (ceil(self.rect.width),ceil(self.rect.height))
 
-    def get_padded_center(self) -> tuple[float, float]:
-        return self.get_padded_rect().center
 
-    def get_padded_top(self) -> float:
-        return self.rect.y + self.padding[1]
+    def get_center(self)->tuple[float,float]:
+        return self.rect.center
 
-    def get_padded_bottom(self) -> float:
-        return self.rect.bottom - self.padding[3]
 
-    def get_debug_outlines(self):
-        if not self.visible:
-            return
-        yield (self.rect, self.debug_color)
-        if any(self.padding):
-            yield (self.get_padded_rect(), self.debug_color)
+    def get_bounding_box(self):
+        yield (self.rect,self._debug_color)
+        yield (self.get_content_rect(),"yellow")
         for child in self.children:
-            yield from child.get_debug_outlines()
-
-    def add_constraints(self, *constraints: "Constraint") -> Self:
-        self.constraints.extend(constraints)
-        seen = set()
-        result = []
-        for c in self.constraints:
-            if not any(c == o for o in seen):
-                result.append(c)
-                seen.add(c.name)
-        self.constraints = result
-        self.constraints.sort(key=lambda c: c.priority)
-        self.dirty_constraints = True
-        self.__constraint_to_ignore = []
+            yield from child.get_bounding_box()
 
+    def set_autoresize(self,value:bool)-> Self:
+        self.autoresize = value
+        self.build()
         return self
 
+    def set_parent(self,parent:Self|None)->None:
+        if self.parent:
+            self.parent.remove_child(self)
+        self.parent = parent
+        self.apply_all_constraints()
+    # SETTERS
+    
+    def set_root(self) -> Self:
+        self.is_root = True
+        return self
+
+    def set_parent_scene(self,scene)->None:
+        super().set_parent_scene(scene)
+        for child in self.children : 
+            child.set_parent_scene(scene)
 
-    def remove_constraints(self, *names: str) -> Self:
-        for c in self.constraints:
-            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 = []
+    def set_x(self,x:float)->Self:
+        delta = x - self.rect.x
+        self.rect.x = x
+        for child in self.children:
+            child.set_x(child.rect.x + delta)
+        self.apply_constraints()
         return self
 
-    def resolve_constraints(self) -> None:
-        if self.parent is None or not self.constraints:
-            self.dirty_constraints = False
-            return
+    def set_y(self,y:float)->Self:
+        delta = y - self.rect.y
+        self.rect.y = y
+        for child in self.children:
+            child.set_y(child.rect.y + delta)
+        self.apply_constraints()
 
-        if not self.__constraint_iteration:
-            self.__constraints_capture = None
-        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
+        return self
+
+    def set_position(self,x:float,y:float)->Self:
+        delta_x = x - self.rect.x
+        delta_y = y - self.rect.y
+        self.rect.topleft = x,y
+        for child in self.children:
+            child.set_position(child.rect.x + delta_x,child.rect.y+delta_y)
+        self.apply_constraints()
+        return self
         
-        # # 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) :
-                        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
+    def set_center(self,x:float,y:float)->Self:
+        delta_x = x - self.rect.centerx
+        delta_y = y - self.rect.centery
+        self.rect.center = x,y
+        for child in self.children:
+            child.set_position(child.rect.x + delta_x,child.rect.y+delta_y)
+        self.apply_constraints()
+        return self
+
 
-        if self.__constraints_to_ignore:
-            print("Constraints ignored : ",[str(c) for c in self.__constraints_to_ignore])
+    def set_size(self, width : float, height: float) -> Self:
+        self.rect.size = (width,height)
+        self.build()
+        return self
         
 
-        self.dirty_constraints = False
+    # Other Methods
 
-    def has_constraint(self, name: str) -> bool:
-        return any(c.name == name for c in self.constraints)
+    def print_tree(self,ident:int=0)->None:
+        print('\t'*ident+self.to_string()+(':' if self.children else ''))
+        for child in self.children :
+            child.print_tree(ident+1)
 
-    def get_root(self) -> "Root":
-        if self.is_root:
-            return self
-        if self.parent:
-            return self.parent.get_root()
-        return None
+    def to_string(self)->str:
+        
+        return f"{self.to_string_id()}@{*self.rect.topleft,* self.rect.size}"
 
-    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.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
-            )
-            i += 1
-        if self.parent:
-            self.parent.do_sort_children = True
-        return self
 
-    def remove(self, *children: "Widget") -> Self:
-        for child in self.children:
-            if child in children:
-                child.set_parent(None).set_parent_scene(None)
-                self.children.remove(child)
-        if self.parent:
-            self.parent.do_sort_children = True
+    def to_string_id(self)->str:
+        return "Widget"
 
-    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 set_size(self, size: tuple) -> Self:
-        size = list(size)
-        if size[0] is None:
-            size[0] = self.rect.w
-        if size[1] is None:
-            size[1] = self.rect.h
-        if size == self.rect.size:
-            return self
-        self.rect.size = size
-        self.dirty_shape = True
-        return self
+    def do_when_removed(self)->None:
+        if self.parent_scene and self.parent == self.parent_scene.root:
+            self.set_parent(None)
 
-    def process_event(self, event: pygame.Event) -> bool:
-        # First propagate to children
-        for child in self.children:
-            child.process_event(event)
-        # return True if the method is blocking (no propagation to next children of the scene)
-        super().process_event(event)
-
-    def update(self, dt) -> None:
-        if self.do_sort_children:
-            self.children.sort(key=lambda c: c.render_order)
-            self.do_sort_children = False
-        _ = [c.update(dt) for c in self.children]
-        super().update(dt)
-
-    def build(self) -> None:
-        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)
-
-    def paint(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
-        return self
+    # Methods on children
 
-    def visit(self, func: Callable, top_down: bool = True, *args, **kwargs) -> None:
-        if top_down:
-            func(self, *args, **kwargs)
-        for child in self.children:
-            child.visit(func, top_down)
-        if not top_down:
-            func(self, *args, **kwargs)
+    def add_child(self,*child:"Widget")->None:
+        for c in child : 
+            self.children.append(c)
+            c.set_parent(self)
+            c.set_parent_scene(self.parent_scene)
+            c.apply_constraints()
+        self.children_modified()
 
-    def visit_up(self, func, *args, **kwargs) -> None:
-        if func(self, *args, **kwargs):
-            return
-        if self.parent:
-            self.parent.visit_up(func, *args, **kwargs)
-
-    def selective_up(self, widget: "Widget"):
-        # if returns True then stop climbing widget tree
-        if widget.parent and widget.parent.dirty_constraints:
-            return False
-        widget.visit(self.selective_down)
-        return True
-
-    def selective_down(self, widget: "Widget"):
-        if widget.constraints:
-            widget.resolve_constraints()
-        else:
-            widget.dirty_constraints = False
-        if widget.dirty_shape:
-            widget.build()
-            widget.dirty_shape = False
-            self.dirty_surface = True
-
-    def draw(self, camera: bf.Camera) -> None:
-        if self.dirty_shape:
-            self.dirty_constraints = True
-            self.dirty_surface = True
-            self.build()
-            self.dirty_shape = False
-            for child in self.children:
-                child.dirty_constraints = True
-
-        if self.dirty_constraints:
-            if self.parent and self.parent.dirty_constraints:
-                self.parent.visit_up(self.selective_up)
-            else:
-                self.visit(lambda c: c.resolve_constraints())
+    def remove_child(self,child:Self)->None:
+        self.children.remove(child)
+        child.set_parent(None)
+        child.set_parent_scene(None)
+        self.children_modified()
 
-        if self.dirty_surface:
-            self.paint()
-            self.dirty_surface = False
 
-        super().draw(camera)
 
-        if self.clip_children:
 
-            new_clip = camera.world_to_screen(self.get_padded_rect())
-            old_clip = camera.surface.get_clip()
-            new_clip = new_clip.clip(old_clip)
-            camera.surface.set_clip(new_clip)
+    # if return True -> don't propagate to siblings or parents
+    def process_event(self, event: pygame.Event)->bool:
+        # First propagate to children
+        for child in self.children:
+            if child.process_event(event):
+                return True
+         #return True if the method is blocking (no propagation to next children of the scene)
+        return super().process_event(event)
 
-        _ = [
-            child.draw(camera)
-            for child in sorted(self.children, key=lambda c: c.render_order)
-        ]
 
-        if self.clip_children:
-            camera.surface.set_clip(old_clip)
+    def update(self,dt:float):
+        for child in self.children:
+            child.update(dt)
+
+    def draw(self, camera: bf.Camera) -> int:
+        self.children.sort(key=lambda e: (e.z_depth,e.render_order))
+        return super().draw(camera) + sum([child.draw(camera) for child in self.children])
+
+    def build(self)->None:
+        """
+        This function is called each time the widget's surface has to be updated
+        It usually has to be overriden if inherited to suit the needs of the new class
+        """
+        if not self.surface: return
+        if self.surface.get_size() != self.get_size_int():
+            self.surface = pygame.Surface(self.get_size_int())
+            if self.parent : self.parent.children_modified()
+
+    def children_modified(self)->None:
+        self.apply_constraints()
+        if self.parent and not self.is_root:
+            self.parent.children_modified()