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

batFramework/gui/widget.py

@@ -1,39 +1,94 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .constraints import Constraint
-    from .root import Root
-    from .interactiveWidget import InteractiveWidget
-from typing import Self
-
+from typing import TYPE_CHECKING,Self,Callable
+from collections.abc import Iterable
 import batFramework as bf
 import pygame
-from math import ceil
-
-MAX_CONSTRAINT_ITERATION = 10
-
+if TYPE_CHECKING :
+    from .constraints.constraints import Constraint
+    from .root import Root
+MAX_CONSTRAINTS = 10
 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
+    def __init__(self,*args,**kwargs) -> None:
+        super().__init__(*args,**kwargs)
         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)
+        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
+
+    def set_clip_children(self,value:bool)->Self:
+        self.clip_children = value
+        self.dirty_surface = True
+        return self
 
-    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],
+    def __str__(self)->str:
+        return "Widget"
+
+    def set_autoresize(self,value:bool)->Self:
+        self.autoresize_w = self.autoresize_h = value
+        self.dirty_shape = True
+        return self
+
+    def set_autoresize_w(self,value:bool)->Self:
+        self.autoresize_w = value
+        self.dirty_shape = True
+        return self
+
+    def set_autoresize_h(self,value:bool)->Self:
+        self.autoresize_h = value
+        self.dirty_shape = True
+        return self
+
+    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 inflate_rect_by_padding(self,rect: pygame.Rect|pygame.FRect)->pygame.Rect|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] 
         )
-        if isinstance(value, list) or isinstance(value, tuple):
+            
+    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 set_parent_scene(self,parent_scene:bf.Scene)->Self:
+        super().set_parent_scene(parent_scene)
+        for c in self.children : 
+            c.set_parent_scene(parent_scene) 
+        return self
+    
+    def set_parent(self,parent:"Widget")->Self:
+        self.parent = parent
+        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):
@@ -45,306 +100,222 @@ class Widget(bf.Entity):
         else:
             self.padding = (value,) * 4
 
-        self.set_size(
-            old_raw_size[0] + self.padding[0] + self.padding[2],
-            old_raw_size[1] + self.padding[1] + self.padding[3],
-        )
+        self.dirty_shape = True
         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 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_min_required_size(self)->tuple[float,float]:
         return self.rect.size
 
-    def get_content_left(self) -> float:
-        return self.rect.left + self.padding[0]
-
-    def get_content_top(self) -> float:
-        return self.rect.top + self.padding[1]
-
-    def get_content_right(self) -> float:
-        return self.rect.right - self.padding[2]
-
-    def get_content_bottom(self) -> float:
-        return self.rect.bottom - self.padding[3]
-
-    def get_content_width(self) -> float:
+    def get_padded_width(self)->float:
         return self.rect.w - self.padding[0] - self.padding[2]
-
-    def get_content_height(self) -> float:
+    
+    def get_padded_height(self)->float:
         return self.rect.h - self.padding[1] - self.padding[3]
+    
+    def get_padded_left(self)->float:
+        return self.rect.left + self.padding[0]
 
-    def get_content_rect(self) -> pygame.FRect:
-        return pygame.FRect(
-            self.rect.left + self.padding[0],
-            self.rect.top + self.padding[1],
-            self.get_content_width(),
-            self.get_content_height(),
-        )
-
-    def get_content_rect_rel(self) -> pygame.FRect:
-        return self.get_content_rect().move(-self.rect.left, -self.rect.top)
-
-    def get_content_center(self) -> tuple[float, float]:
-        return self.get_content_rect().center
-
-    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 top_at(self, x: float|int, y: float|int) -> "None|Widget":
-        if self.visible and self.rect.collidepoint(x, y):
-            if self.children:
-                for child in reversed(self.children):
-                    r = child.top_at(x, y)
-                    if r is not None:
-                        return r
-            return self
-
-        return None
+    def get_padded_right(self)->float:
+        return self.rect.right + self.padding[2]
 
-    def get_constraint(self, name: str) -> Constraint | None:
-        return next((c for c in self.constraints if c.name == name), None)
+    def get_padded_center(self)->tuple[float,float]:
+        return self.get_padded_rect().center
 
-    def add_constraints(self, *constraints: Constraint) -> Self:
-        for constraint in constraints:
-            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_top(self)->float:
+        return self.rect.y + self.padding[1]
 
-    def has_constraint(self, name: str) -> bool:
-        return any(c.name == name for c in self.constraints)
+    def get_padded_bottom(self)->float:
+        return self.rect.bottom - self.padding[3] 
 
-    def apply_all_constraints(self) -> None:
+    def get_debug_outlines(self):
+        yield (self.rect, self.debug_color)
+        if any(self.padding) : yield (self.get_padded_rect(),"gray")
         for child in self.children:
-            child.apply_all_constraints()
-        self.apply_constraints()
+            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 c.name not in seen:
+                result.append(c)
+                seen.add(c.name)
+        self.constraints = result
+        self.constraints.sort(key=lambda c : c.priority)
+        self.dirty_constraints = True
+        return self
 
-    def apply_constraints(self) -> None:
-        if not self.parent:
-            # print(f"Warning : can't apply constraints on {self.to_string()} without parent widget")
-            return
-        if not self.constraints:
+    def resolve_constraints(self)->None:
+        if self.parent is None or not self.constraints:
+            self.dirty_constraints = False
             return
-        # Sort constraints based on priority
-        self.constraints.sort(key=lambda c: c.priority)
-
-        for iteration in range(MAX_CONSTRAINT_ITERATION):
-            unsatisfied = []  # Initialize a flag
-
+        all_good = False
+        constraint_iteration = 0
+        while not all_good:
             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_CONSTRAINT_ITERATION - 1:
-                unsatisfied_constraints = '\n\t'.join([c.to_string() for c in unsatisfied])
-                raise ValueError(
-                    f"[WARNING] Following constraints for {self.to_string()} were not satisfied : \n{unsatisfied_constraints}"
-                    )
-
-    # GETTERS
-    def get_by_tags(self, *tags :str):
-        for c in self.children:
-            yield from c.get_by_tags(*tags)
-        if any(self.has_tags(t) for t in tags):
-            yield self
-
-    def count_children_recursive(self):
-        return 1 + sum(child.count_children_recursive() for child in self.children)
-
-
-    def propagate_function(self,function):
-        function(self)
-        for child in self.children:
-            child.propagate_function(function)
-
-    def get_root(self) -> Root | None:
-        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_size_int(self) -> tuple[int, int]:
-        return (ceil(self.rect.width), ceil(self.rect.height))
+                if not constraint.evaluate(self.parent,self):
+                    constraint.apply(self.parent,self)
+                    # print(constraint.name,"Applied")
+            constraint_iteration += 1
+            if  all(c.evaluate(self.parent,self) for c in self.constraints):
+               all_good = True
+               break
+            elif self.__constraint_iteration > MAX_CONSTRAINTS:
+                print(self,"CONSTRAINTS ERROR",list(c.name for c in self.constraints if not c.evaluate(self.parent,self)))
+                self.dirty_constraints = False
+                return
+        # print("DONE")
+        self.dirty_constraints = False
+
+    def remove_constraints(self,*names:str)->Self:
+        self.constraints = [c for c in self.constraints if c.name not in names]
+        return self
 
-    def get_center(self) -> tuple[float, float]:
-        return self.rect.center
+    def has_constraint(self,name:str)->bool:
+        return any(c.name == name for c in self.constraints )
 
-    def get_bounding_box(self):
-        yield (self.rect, self.debug_color)
-        yield (self.get_content_rect(), "yellow")
+    def visit(self,func:Callable,top_down:bool = True)->None:
+        if top_down : func(self)
         for child in self.children:
-            yield from child.get_bounding_box()
+            child.visit(func,top_down)
+        if not top_down: func(self)
 
-    def set_autoresize(self, value: bool) -> Self:
-        self.autoresize = value
-        self.build()
-        return self
+    def get_root(self)->"Root":
+        if self.is_root:
+            return self
+        return self.parent.get_root()
 
-    def set_parent(self, parent: Self | None) -> Self:
+    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.remove_child(self)
-        self.parent = parent
-        self.apply_all_constraints()
+            self.parent.do_sort_children = True
         return self
 
-    # SETTERS
-
-    def set_root(self) -> Self:
-        self.is_root = True
-        return self
-
-    def set_parent_scene(self, scene) -> Self:
-        super().set_parent_scene(scene)
-        for child in self.children:
-            child.set_parent_scene(scene)
-        return self
-    def set_x(self, x: float) -> Self:
-        if x == self.rect.x : return 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 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 set_y(self, y: float) -> Self:
-        if y == self.rect.y : return 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()
-        return self
+    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
 
-    def set_position(self, x: float, y: float) -> Self:
-        if self.rect.topleft == (x,y) : return 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
+        self.set_size(size)
 
-    def set_center(self, x: float, y: float) -> Self:
-        if self.rect.center == (x,y) : return 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
 
-    def set_size(self, width: float, height: float) -> Self:
-        if width is None : width = self.rect.w
-        if height is None : height = self.rect.h
-        if self.rect.size == (width,height) : return self
-        self.rect.size = (width, height)
-        self.build()
-        self.apply_constraints()
-        self.children_modified()
+    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
+    
 
-    # Other Methods
-
-    def print_tree(self, ident: int = 0) -> None:
-        print("\t" * ident + self.to_string() + (":" if self.children else ""))
+    def process_event(self, event: pygame.Event) -> bool:
+        # First propagate to children
         for child in self.children:
-            child.print_tree(ident + 1)
-
-    def to_string(self) -> str:
-        return f"{self.to_string_id()}@{*self.rect.topleft,* self.rect.size}"
-
-    def to_string_id(self) -> str:
-        return "Widget"
+            child.process_event(event)
+        # return True if the method is blocking (no propagation to next children of the scene)
+        super().process_event(event)
 
-    def do_when_removed(self) -> None:
-        if self.parent_scene and self.parent == self.parent_scene.root:
-            self.set_parent(None)
-
-    # Methods on children
-
-    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.do_when_added()
-        self._sort_children()
-        self.apply_all_constraints()
-        self.children_modified()
-
-    def remove_child(self, child: "Widget") -> None:
-        try : 
-            self.children.remove(child)
-        except ValueError:
-            return
-        child.set_parent(None)
-        child.do_when_removed()
-        child.set_parent_scene(None)
-        self._sort_children()
-        self.apply_all_constraints()
-        self.children_modified()
 
-    def _sort_children(self):
-        self.children.sort(key=lambda child : child.render_order)
+    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)
 
 
-    # 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)
+    def build(self)->None:
+        new_size =tuple(map(int,self.rect.size))       
+        if self.surface.get_size() != new_size:
+            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()
 
-    def update(self, dt: float):
-        for child in self.children:
-            child.update(dt)
-        self.do_update(dt)
+    def paint(self)->None:
+        self.surface.fill((0,0,0,0))
+        return self
 
-    def draw(self, camera: bf.Camera) -> int:
-        return super().draw(camera) + sum(
-            [child.draw(camera) for child in self.children]
-        )
+    def visit_up(self,func)->None:
+        if func(self) : return
+        if self.parent:
+            self.parent.visit_up(func)
+
+    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 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.dirty_surface : 
+            self.paint()
+            self.dirty_surface = False
 
 
-    def build_all(self) -> None:
-        self.build()
-        for child in self.children:
-            child.build_all()
 
-    def children_modified(self) -> None:
-        if self.parent and not self.is_root:
-            self.parent.children_modified()
+        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)
 
+        _ = [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)