batframework 1.0.7__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/gui/constraints.py

@@ -1,30 +1,44 @@
 from .widget import Widget
 import batFramework as bf
 
+
 class Constraint:
-    def __init__(self, name="Constraint", priority=0):
+    def __init__(self,name="Constraint", priority=0):
         self.priority = priority
         self.name = name
-
-    def set_priority(self, priority) -> "Constraint":
+    def set_priority(self, priority)->"Constraint":
         self.priority = priority
         return self
-
-    def to_string(self) -> str:
+    def to_string(self)->str:
         return f"{self.name.upper()}"
-
-    def evaluate(self, parent_widget: Widget, child_widget: Widget) -> bool:
+        
+    def evaluate(self, parent_widget:Widget, child_widget:Widget) -> bool:
         raise NotImplementedError("Subclasses must implement evaluate method")
 
-    def apply(self, parent_widget: Widget, child_widget: Widget = None) -> bool:
+    def apply(self, parent_widget:Widget, child_widget:Widget=None) -> bool:
         if not self.evaluate(parent_widget, child_widget):
             self.apply_constraint(parent_widget, child_widget)
             return False
         return True
-
-    def apply_constraint(self, parent_widget: Widget, child_widget: Widget):
+        
+    def apply_constraint(self, parent_widget:Widget, child_widget:Widget):
         raise NotImplementedError("Subclasses must implement apply_constraint method")
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 class ConstraintMinWidth(Constraint):
     def __init__(self, width):
         super().__init__(name="min_width")
@@ -35,9 +49,11 @@ class ConstraintMinWidth(Constraint):
 
     def apply_constraint(self, parent_widget, child_widget):
         if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_size(self.min_width, child_widget.rect.h)
+            child_widget.set_size(self.min_width,child_widget.rect.h)
 
 
+            
+    
 class ConstraintCenterX(Constraint):
     def __init__(self):
         super().__init__(name="centerx")
@@ -45,12 +61,9 @@ class ConstraintCenterX(Constraint):
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.centerx == parent_widget.get_content_center()[0]
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_center(
-                parent_widget.get_content_center()[0], child_widget.rect.centery
-            )
-
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_center(parent_widget.get_content_center()[0],child_widget.rect.centery)
 
 class ConstraintCenterY(Constraint):
     def __init__(self):
@@ -59,12 +72,9 @@ class ConstraintCenterY(Constraint):
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.centery == parent_widget.get_content_center()[1]
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_center(
-                child_widget.rect.centerx, parent_widget.get_content_center()[1]
-            )
-
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_center(child_widget.rect.centerx,parent_widget.get_content_center()[1])
 
 class ConstraintCenter(Constraint):
     def __init__(self):
@@ -73,205 +83,122 @@ class ConstraintCenter(Constraint):
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.center == parent_widget.get_content_center()
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
             child_widget.set_center(*parent_widget.get_content_center())
 
-
 class ConstraintPercentageWidth(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = True):
+    def __init__(self,percentage:float,keep_autoresize:bool=True):
         super().__init__(name="percentage_width")
-        self.percentage: float = percentage
+        self.percentage:float = percentage
         self.keep_autoresize: bool = keep_autoresize
-
-    def to_string(self) -> str:
-        return f"{super().to_string()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
-
+    def to_string(self)->str:
+        return f"{super().to_string()}.[{self.percentage},{self.keep_autoresize}]"
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == round(
-            parent_widget.get_content_width() * self.percentage
-        )
+        return child_widget.rect.width == round(parent_widget.get_content_width() * self.percentage)
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
             if child_widget.autoresize:
                 if self.keep_autoresize:
-                    print(
-                        f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True"
-                    )
-                    return
+                    print(f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True")
+                    return 
                 child_widget.set_autoresize(False)
-            child_widget.set_size(
-                round(parent_widget.get_content_width() * self.percentage),
-                child_widget.rect.h,
-            )
+            child_widget.set_size(round(parent_widget.get_content_width() * self.percentage) ,child_widget.rect.h)
 
 
 class ConstraintPercentageHeight(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = True):
+    def __init__(self,percentage:float,keep_autoresize:bool=True):
         super().__init__(name="percentage_height")
-        self.percentage: float = percentage
+        self.percentage:float = percentage
         self.keep_autoresize: bool = keep_autoresize
 
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == round(
-            parent_widget.get_content_height() * self.percentage
-        )
-        
-    def to_string(self) -> str:
-        return f"{super().to_string()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
+        return child_widget.rect.height == round(parent_widget.get_content_height() * self.percentage)
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
             if child_widget.autoresize:
                 if self.keep_autoresize:
-                    print(
-                        f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True"
-                    )
-                    return
+                    print(f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True")
+                    return 
                 child_widget.set_autoresize(False)
-            child_widget.set_size(
-                child_widget.rect.w,
-                round(parent_widget.get_content_height() * self.percentage),
-            )
-
+            child_widget.set_size(child_widget.rect.w,round(parent_widget.get_content_height() * self.percentage))
 
 class ConstraintHeight(Constraint):
-    def __init__(self, height: float, keep_autoresize: bool = True):
-        if height < 0:
+    def __init__(self,height:float):
+        if height < 0 :
             raise ValueError("height can't be negative")
         super().__init__(name="height")
         self.height = height
-        self.keep_autoresize:bool = keep_autoresize
 
-    def to_string(self) -> str:
-        return f"{super().to_string()}.(height={self.height})"
+    def to_string(self)->str:
+        return f"{super().to_string()}.({self.height})"
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.height == self.height
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            if child_widget.autoresize:
-                if self.keep_autoresize:
-                    print(
-                        f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True"
-                    )
-                    return
-                child_widget.set_autoresize(False)
-            child_widget.set_size(child_widget.rect.w, self.height)
-
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_size(child_widget.rect.w,self.height)
 
 class ConstraintWidth(Constraint):
-    def __init__(self, width: float, keep_autoresize: bool = True):
-        if width < 0:
+    def __init__(self,width:float):
+        if width < 0 :
             raise ValueError("width can't be negative")
         super().__init__(name="width")
         self.width = width
-        self.keep_autoresize : bool = keep_autoresize
 
-    def to_string(self) -> str:
-        return f"{super().to_string()}.(width={self.width})"
+    def to_string(self)->str:
+        return f"{super().to_string()}.({self.width})"
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.width == self.width
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            if child_widget.autoresize:
-                if self.keep_autoresize:
-                    print(
-                        f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True"
-                    )
-                    return
-                child_widget.set_autoresize(False)
-            child_widget.set_size(self.width, child_widget.rect.h)
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_size(self.width,child_widget.rect.h)
 
 
 class ConstraintAspectRatio(Constraint):
-    def __init__(self, ratio: int | float = 1):
+    def __init__(self,ratio:int|float=1):
         super().__init__(name="aspect_ratio")
-        if isinstance(ratio, float | int):
+        if isinstance(ratio, float|int):
             self.ratio = ratio
-        elif isinstance(ratio, Widget):
+        elif isinstance(ratio,Widget):
             self.ratio = ratio.rect.w / ratio.rect.h
         else:
             raise TypeError(f"Ratio must be float or Widget")
-
-    def evaluate(self, parent_widget, child_widget):
-        return self.ratio == child_widget.rect.w / child_widget.rect.h
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            return  # TODO
-
-
+    def evaluate(self, parent_widget,child_widget):
+        return  self.ratio  ==  child_widget.rect.w / child_widget.rect.h
+        
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            return # TODO
+    
 class ConstraintAnchorBottom(Constraint):
     def __init__(self):
         super().__init__(name="anchor_bottom")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.bottom == parent_widget.get_content_bottom()
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
+        
+    def evaluate(self, parent_widget,child_widget):
+        return  child_widget.rect.bottom == parent_widget.rect.bottom
+        
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
             child_widget.set_y(parent_widget.get_content_bottom() - child_widget.rect.h)
 
 
 class ConstraintAnchorTopRight(Constraint):
     def __init__(self):
         super().__init__(name="anchor_topright")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.topright == parent_widget.get_content_rect().topright
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_position(
-                parent_widget.get_content_right() - child_widget.rect.w,
-                parent_widget.get_content_top(),
-            )
-
-class ConstraintAnchorBottomRight(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_bottomright")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.bottomright == parent_widget.get_content_rect().bottomright
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_position(
-                parent_widget.get_content_right() - child_widget.rect.w,
-                parent_widget.get_content_bottom() - child_widget.rect.h,
-            )
-
-
-
-class ConstraintAnchorRight(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_right")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.right == parent_widget.get_content_right()
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_position(
-                parent_widget.get_content_right() - child_widget.rect.w,
-                child_widget.rect.top,
-            )
+        
+    def evaluate(self, parent_widget,child_widget):
+        return  child_widget.rect.topright == parent_widget.rect.topright
+        
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_position(parent_widget.get_content_right()-child_widget.rect.w, parent_widget.get_content_top())
 
 
-class ConstraintAnchorLeft(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_left")
 
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.left == parent_widget.get_content_left()
 
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_position(
-                parent_widget.get_content_left(), child_widget.rect.top
-            )

batFramework/gui/container.py

@@ -1,60 +1,49 @@
 import batFramework as bf
 from .widget import Widget
-from .layout import Layout,Column
+from .layout import Layout
 from .constraints import Constraint
 from typing import Self
 
 class Container(Widget):
-    def __init__(self, layout: Layout = Column(), *children: Widget)->None:
+    def __init__(self, layout:Layout=None, *children:Widget):
         super().__init__()
         self.set_debug_color("green")
         self.surface = None
-        self.layout: Layout = layout
-        if self.layout:
-            self.layout.set_parent(self)
+        self.layout :Layout = layout
+        if self.layout : self.layout.set_parent(self)
         for child in children:
             self.add_child(child)
 
-    def set_padding(self,value)->Self:
-        return self
-
-    def set_layout(self, layout: Layout) -> Self:
+    def set_layout(self,layout:Layout)->Self:
         self.layout = layout
         self.apply_constraints()
         return self
 
     def get_bounding_box(self):
-        yield (self.rect, self.debug_color)
+        yield (self.rect,self._debug_color)
         for child in self.children:
             yield from child.get_bounding_box()
 
-    def clear_children(self) -> None:
+    def clear_children(self)->None:
         self.children.clear()
         self.apply_constraints()
 
-    def add_child(self, *child: Widget) -> None:
+    def add_child(self,*child:Widget)->None:
         super().add_child(*child)
-        if self.layout:
-            self.layout.arrange()
+        if self.layout : self.layout.arrange()
 
-    def remove_child(self, child: Widget) -> None:
+    def remove_child(self,child:Widget)->None:
         super().remove_child(child)
-        if self.layout:
-            self.layout.arrange()
+        if self.layout : self.layout.arrange()
 
-    def build(self) -> None:
+    def build(self)->None:
         super().build()
-        if self.layout:
-            self.layout.arrange()
+        if self.layout : self.layout.arrange()
 
-    def apply_constraints(self) -> None:
+    def apply_constraints(self)->None:
         super().apply_constraints()
-        if self.layout:
-            self.layout.arrange()
-
-    def to_string_id(self) -> str:
-        return f"Container({self.uid},{len(self.children)},{[c.to_string() for c in self.constraints]})"
+        if self.layout : self.layout.arrange()
 
-    def children_modified(self)->None:
-        self.apply_all_constraints()
-        super().children_modified()
+    def to_string_id(self)->str:
+        return f"Container({len(self.children)},{[c.to_string() for c in self.constraints]})"
+    

batFramework/gui/debugger.py

@@ -1,111 +1,47 @@
 from .label import Label
 from typing import Self
-import batFramework as bf
-import pygame
-
-
-def convert_to_int(*args):
-    return [int(arg) for arg in args]
 
 class Debugger(Label):
-    def __init__(self) -> None:
-        super().__init__("")
-        self.static_data: dict = {}
-        self.dynamic_data: dict = {}
-        self.refresh_rate = 10
-        self.refresh_counter : float = 0
-        self.render_order = 99
-        self.set_uid("debugger")
-
-    def get_bounding_box(self):
-        yield None
-    def to_string_id(self) -> str:
-        return "Debugger"
-
-    def set_refresh_rate(self, value: int) -> Self:
-        self.refresh_rate = value
-        return self
-
-    def add_static(self, key: str, data):
-        self.static_data[key] = str(data)
-        self.update_text()
-
-    def add_dynamic(self, key: str, func) -> None:
-        self.dynamic_data[key] = func
-        self.update_text()
-
-    def remove_static(self,key)->bool:
-        try:
-            self.static_data.pop(key)
-            return True
-        except KeyError:
-            return False
-
-    def remove_dynamic(self,key)->bool:
-        try:
-            self.dynamic_data.pop(key)
-            return True
-        except KeyError:
-            return False
-
-    def set_parent_scene(self, scene) -> Self:
-        super().set_parent_scene(scene)
-        self.update_text()
-        return self
-
-    def update_text(self) -> None:
-        if not self.parent_scene:
-            return
-        d = "\n".join(
-            key + ":" + data if key != "" else data
-            for key, data in self.static_data.items()
-        )
-        d2 = "\n".join(
-            key + ":" + str(data()) if key != "" else str(data())
-            for key, data in self.dynamic_data.items()
-        )
-        self.set_text("\n".join((d, d2)).strip())
-
-    def update(self, dt: float) -> None:
-        if not self.parent_scene:
-            return
-        if self.parent_scene.get_sharedVar("debugging_mode") != 1:
-            self.set_visible(False)
-            return
-        self.set_visible(True)
-        self.refresh_counter = self.refresh_counter + (dt * 60)
-        if self.refresh_counter > self.refresh_rate:
-            self.refresh_counter = 0
-            self.update_text()
-
-
-class BasicDebugger(Debugger):
-    def __init__(self):
-        super().__init__()
-
-    def do_when_added(self):
-        if not self.parent_scene or  not self.parent_scene.manager:
-            print("Debugger could not link to the manager")
-            return
-        manager_link = self.parent_scene.manager
-        parent_scene = self.parent_scene
-        self.add_static("Resolution", 'x'.join(str(i) for i in bf.const.RESOLUTION))
-        self.add_dynamic(
-            "FPS", lambda: str(round(manager_link.get_fps()))
-        )
-        self.add_dynamic("Mouse", pygame.mouse.get_pos)
-        self.add_dynamic(
-            "World",
-            lambda: convert_to_int(*parent_scene.camera.convert_screen_to_world(
-                *pygame.mouse.get_pos())
-            ),
-        )
-        self.add_dynamic(
-            "Hud",
-            lambda: convert_to_int(*parent_scene.hud_camera.convert_screen_to_world(
-                *pygame.mouse.get_pos())
-            ),
-        )
-        self.add_dynamic("W. Ent.",lambda : parent_scene.get_world_entity_count())
-        self.add_dynamic("H. Ent.",lambda : parent_scene.get_hud_entity_count())
+	def __init__(self)->None:
+		super().__init__("")
+		self.static_data : dict 	= {}
+		self.dynamic_data : dict 	= {}
+		self.refresh_rate = 10
+		self.refresh_counter = 0
+		self.render_order = 99
+
+	def to_string_id(self)->str:
+		return "Debugger"
+		
+	def set_refresh_rate(self, value:int)-> Self:
+		self.refresh_rate = value
+		return self
+		
+	def add_data(self,key:str,data):
+		self.static_data[key] = str(data)
+		self.update_text()
+		
+	def add_dynamic_data(self,key:str,func)->None:
+		self.dynamic_data[key] = func
+		self.update_text()
+
+	def set_parent_scene(self,scene)->None:
+	    super().set_parent_scene(scene)
+	    self.update_text()
         
+	def update_text(self)->None:
+		if not self.parent_scene:return	
+		d = '\n'.join(key+':'+data if key!='' else data for key,data in self.static_data.items())
+		d2 = '\n'.join(key+':'+str(data()) if key!='' else str(data()) for key,data in self.dynamic_data.items())
+		self.set_text('\n'.join((d,d2)).strip())
+
+	def update(self,dt:float)->None:
+		if not self.parent_scene:return
+		if self.parent_scene.get_sharedVar("is_debugging_func")() != 1:
+			self.set_visible(False)
+			return
+		self.set_visible(True)
+		self.refresh_counter = self.refresh_counter + (dt * 60) 
+		if self.refresh_counter > self.refresh_rate:
+			self.refresh_counter = 0
+			self.update_text()

batFramework/gui/frame.py

@@ -4,22 +4,16 @@ import pygame
 
 
 class Frame(Shape):
-    def __init__(self, width: float, height: float,fit_to_children:bool=True):
-        self.fit_to_children = fit_to_children
-        super().__init__(width, height)
+    def __init__(self,width:float,height:float):
+        super().__init__(width,height)
         self.set_debug_color("magenta")
-    def to_string_id(self) -> str:
+
+    def to_string_id(self)->str:
         return "Frame"
 
-    def _fit_to_children(self)->None:
-        # TODO CLEAN THIS UP
-        if not self.children: return
-        children_rect = self.children[0].rect.unionall(list(c.rect for c in self.children))
-        self.set_size(*self.inflate_rect_by_padding(children_rect).size)
-        self.rect.center = children_rect.center
-        self.apply_all_constraints()
-        
-    def children_modified(self) -> None:
+    def children_modified(self)->None:
+        print(self.children)
+        self.set_size(
+            *self.inflate_rect_by_padding(self.rect.unionall(list(c.rect for c in self.children))).size
+        )
         super().children_modified()
-        if self.fit_to_children:
-            self._fit_to_children()