batframework 1.0.8a1__py3-none-any.whl → 1.0.8a3__py3-none-any.whl

batFramework/gui/widget.py

@@ -1,89 +1,129 @@
-from typing import TYPE_CHECKING,Self,Callable
+from typing import TYPE_CHECKING, Self, Callable
 from collections.abc import Iterable
 import batFramework as bf
 import pygame
-if TYPE_CHECKING :
+
+if TYPE_CHECKING:
     from .constraints.constraints import Constraint
     from .root import Root
 MAX_CONSTRAINTS = 10
-class Widget(bf.Entity):
-    def __init__(self,*args,**kwargs) -> None:
-        super().__init__(*args,**kwargs)
+
+
+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.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:
+    def show(self) -> Self:
+        self.visit(lambda w: w.set_visible(True))
+        return self
+
+    def hide(self) -> Self:
+        self.visit(lambda w: w.set_visible(False))
+        return self
+
+    def set_clip_children(self, value: bool) -> Self:
         self.clip_children = value
         self.dirty_surface = True
         return self
 
-    def __str__(self)->str:
+    def __str__(self) -> str:
         return "Widget"
 
-    def set_autoresize(self,value:bool)->Self:
+    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:
+    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:
+    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:
+    def set_render_order(self, render_order: int) -> Self:
         super().set_render_order(render_order)
-        if self.parent:self.parent.do_sort_children = True
+        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:
+    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] 
+            rect[3] + self.padding[1] + self.padding[3],
         )
-            
+
     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]
+        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_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:
+    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) 
+        if parent_scene is None:
+            bf.StyleManager().remove_widget(self)
+
+        for c in self.children:
+            c.set_parent_scene(parent_scene)
         return self
-    
-    def set_parent(self,parent:"Widget")->Self:
+
+    def set_parent(self, parent: "Widget") -> Self:
+        if parent == self.parent:
+            return self
+        if self.parent is not None:
+            self.parent.remove(self)
         self.parent = parent
         return self
 
@@ -103,42 +143,47 @@ class Widget(bf.Entity):
         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])
+    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 get_min_required_size(self)->tuple[float,float]:
+    def get_min_required_size(self) -> tuple[float, float]:
         return self.rect.size
 
-    def get_padded_width(self)->float:
+    def get_padded_width(self) -> float:
         return self.rect.w - self.padding[0] - self.padding[2]
-    
-    def get_padded_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:
+
+    def get_padded_left(self) -> float:
         return self.rect.left + self.padding[0]
 
-    def get_padded_right(self)->float:
+    def get_padded_right(self) -> float:
         return self.rect.right + self.padding[2]
 
-    def get_padded_center(self)->tuple[float,float]:
+    def get_padded_center(self) -> tuple[float, float]:
         return self.get_padded_rect().center
 
-    def get_padded_top(self)->float:
+    def get_padded_top(self) -> float:
         return self.rect.y + self.padding[1]
 
-    def get_padded_bottom(self)->float:
-        return self.rect.bottom - self.padding[3] 
+    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(),"gray")
+        if any(self.padding):
+            yield (self.get_padded_rect(), self.debug_color)
         for child in self.children:
             yield from child.get_debug_outlines()
 
-    def add_constraints(self,*constraints:"Constraint")->Self:
+    def add_constraints(self, *constraints: "Constraint") -> Self:
         self.constraints.extend(constraints)
         seen = set()
         result = []
@@ -147,11 +192,11 @@ class Widget(bf.Entity):
                 result.append(c)
                 seen.add(c.name)
         self.constraints = result
-        self.constraints.sort(key=lambda c : c.priority)
+        self.constraints.sort(key=lambda c: c.priority)
         self.dirty_constraints = True
         return self
 
-    def resolve_constraints(self)->None:
+    def resolve_constraints(self) -> None:
         if self.parent is None or not self.constraints:
             self.dirty_constraints = False
             return
@@ -159,34 +204,36 @@ class Widget(bf.Entity):
         constraint_iteration = 0
         while not all_good:
             for constraint in self.constraints:
-                if not constraint.evaluate(self.parent,self):
-                    constraint.apply(self.parent,self)
+                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
+            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)))
+                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:
+    def remove_constraints(self, *names: str) -> Self:
         self.constraints = [c for c in self.constraints if c.name not in names]
         return self
 
-    def has_constraint(self,name:str)->bool:
-        return any(c.name == name for c in self.constraints )
-
-    def visit(self,func:Callable,top_down:bool = True)->None:
-        if top_down : func(self)
-        for child in self.children:
-            child.visit(func,top_down)
-        if not top_down: func(self)
+    def has_constraint(self, name: str) -> bool:
+        return any(c.name == name for c in self.constraints)
 
-    def get_root(self)->"Root":
+    def get_root(self) -> "Root":
         if self.is_root:
             return self
         return self.parent.get_root()
@@ -194,31 +241,33 @@ class Widget(bf.Entity):
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
         if self.children:
             for child in reversed(self.children):
-                if child.visible: 
+                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:
+    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)
+            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[:]:
+    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)
+                child.set_parent(None).set_parent_scene(None)
         if self.parent:
             self.parent.do_sort_children = True
 
-    def set_size_if_autoresize(self,size:tuple[float,float])->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
@@ -227,15 +276,17 @@ class Widget(bf.Entity):
 
         return self
 
-    def set_size(self,size:tuple)->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
+        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 process_event(self, event: pygame.Event) -> bool:
         # First propagate to children
@@ -244,40 +295,48 @@ class Widget(bf.Entity):
         # return True if the method is blocking (no propagation to next children of the scene)
         super().process_event(event)
 
-
-    def update(self,dt)->None:
+    def update(self, dt) -> None:
         if self.do_sort_children:
-            self.children.sort(key = lambda c : c.render_order)
+            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))       
+    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()
+            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 paint(self)->None:
-        self.surface.fill((0,0,0,0))
+    def paint(self) -> None:
+        self.surface.fill((0, 0, 0, 0))
         return self
 
-    def visit_up(self,func)->None:
-        if func(self) : return
+    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 visit_up(self, func, *args, **kwargs) -> None:
+        if func(self, *args, **kwargs):
+            return
         if self.parent:
-            self.parent.visit_up(func)
+            self.parent.visit_up(func, *args, **kwargs)
 
-    def selective_up(self,widget:"Widget"):
+    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 :
+    def selective_down(self, widget: "Widget"):
+        if widget.constraints:
             widget.resolve_constraints()
         else:
             widget.dirty_constraints = False
@@ -286,29 +345,27 @@ class Widget(bf.Entity):
             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 :
+            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())
+                self.visit(lambda c: c.resolve_constraints())
 
-        if self.dirty_surface : 
+        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())
@@ -316,6 +373,10 @@ class Widget(bf.Entity):
             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)]
+        _ = [
+            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)
+            camera.surface.set_clip(old_clip)

batFramework/object.py

@@ -25,12 +25,12 @@ class Object:
         Object.__instance_count += 1
         return i
 
-    def set_position(self,x,y)->Self:
-        self.rect.topleft = x,y
+    def set_position(self, x, y) -> Self:
+        self.rect.topleft = x, y
         return self
 
-    def set_center(self,x,y)->Self:
-        self.rect.center = x,y
+    def set_center(self, x, y) -> Self:
+        self.rect.center = x, y
         return self
 
     def get_debug_outlines(self):
@@ -41,8 +41,9 @@ class Object:
         return self
 
     def set_parent_scene(self, scene) -> Self:
-        if scene == self.parent_scene : return self
-        if self.parent_scene is not  None:
+        if scene == self.parent_scene:
+            return self
+        if self.parent_scene is not None:
             self.do_when_removed()
         self.parent_scene = scene
         if scene is not None:
@@ -59,9 +60,6 @@ class Object:
         self.uid = uid
         return self
 
-    def get_uid(self) -> int:
-        return self.uid
-
     def add_tags(self, *tags) -> Self:
         for tag in tags:
             if tag not in self.tags:
@@ -82,7 +80,8 @@ class Object:
         """
         Returns bool : True if the method is blocking (no propagation to next object of the scene)
         """
-        if event.consumed : return
+        if event.consumed:
+            return
         self.do_process_actions(event)
         self.do_handle_event(event)
 

batFramework/renderGroup.py

@@ -7,8 +7,11 @@ from typing import Self, Iterator, Callable
 + fblits
 """
 
+
 class RenderGroup(bf.Entity):
-    def __init__(self, entity_iterator: Callable[[],Iterator[bf.Entity]], blit_flags: int = 0) -> None:
+    def __init__(
+        self, entity_iterator: Callable[[], Iterator[bf.Entity]], blit_flags: int = 0
+    ) -> None:
         super().__init__()
         self.entity_iterator = entity_iterator
         self.set_blit_flags(blit_flags)
@@ -57,6 +60,8 @@ class RenderGroup(bf.Entity):
         if not self.visible:
             return
         fblits_data = (
-            (e.surface, (e.rect.x - camera.rect.x,e.rect.y - camera.rect.y)) for e in self.entity_iterator() if camera.rect.colliderect(e.rect)
+            (e.surface, (e.rect.x - camera.rect.x, e.rect.y - camera.rect.y))
+            for e in self.entity_iterator()
+            if camera.rect.colliderect(e.rect)
         )
         camera.surface.fblits(fblits_data, self.blit_flags)