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

batFramework/gui/constraints.py

@@ -0,0 +1,204 @@
+from .widget import Widget
+import batFramework as bf
+
+
+class Constraint:
+    def __init__(self,name="Constraint", priority=0):
+        self.priority = priority
+        self.name = name
+    def set_priority(self, priority)->"Constraint":
+        self.priority = priority
+        return self
+    def to_string(self)->str:
+        return f"{self.name.upper()}"
+        
+    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:
+        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):
+        raise NotImplementedError("Subclasses must implement apply_constraint method")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class ConstraintMinWidth(Constraint):
+    def __init__(self, width):
+        super().__init__(name="min_width")
+        self.min_width = width
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.width >= self.min_width
+
+    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)
+
+
+            
+    
+class ConstraintCenterX(Constraint):
+    def __init__(self):
+        super().__init__(name="centerx")
+
+    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)
+
+class ConstraintCenterY(Constraint):
+    def __init__(self):
+        super().__init__(name="centery")
+
+    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])
+
+class ConstraintCenter(Constraint):
+    def __init__(self):
+        super().__init__(name="center")
+
+    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):
+            child_widget.set_center(*parent_widget.get_content_center())
+
+class ConstraintPercentageWidth(Constraint):
+    def __init__(self,percentage:float,keep_autoresize:bool=True):
+        super().__init__(name="percentage_width")
+        self.percentage:float = percentage
+        self.keep_autoresize: bool = 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)
+
+    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(round(parent_widget.get_content_width() * self.percentage) ,child_widget.rect.h)
+
+
+class ConstraintPercentageHeight(Constraint):
+    def __init__(self,percentage:float,keep_autoresize:bool=True):
+        super().__init__(name="percentage_height")
+        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 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,round(parent_widget.get_content_height() * self.percentage))
+
+class ConstraintHeight(Constraint):
+    def __init__(self,height:float):
+        if height < 0 :
+            raise ValueError("height can't be negative")
+        super().__init__(name="height")
+        self.height = 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):
+            child_widget.set_size(child_widget.rect.w,self.height)
+
+class ConstraintWidth(Constraint):
+    def __init__(self,width:float):
+        if width < 0 :
+            raise ValueError("width can't be negative")
+        super().__init__(name="width")
+        self.width = 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):
+            child_widget.set_size(self.width,child_widget.rect.h)
+
+
+class ConstraintAspectRatio(Constraint):
+    def __init__(self,ratio:int|float=1):
+        super().__init__(name="aspect_ratio")
+        if isinstance(ratio, float|int):
+            self.ratio = ratio
+        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
+    
+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.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.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())
+
+
+
+

batFramework/gui/container.py

@@ -1,173 +1,49 @@
 import batFramework as bf
 from .widget import Widget
-from .shape import Shape
-from .interactiveWidget import InteractiveWidget
-from .layout import Layout, Column
+from .layout import Layout
+from .constraints import Constraint
 from typing import Self
-import pygame
-from pygame.math import Vector2
 
-
-class Container(Shape, InteractiveWidget):
-    def __init__(self, layout: Layout = None, *children: Widget) -> None:
+class Container(Widget):
+    def __init__(self, layout:Layout=None, *children:Widget):
         super().__init__()
-        self.dirty_children = False
         self.set_debug_color("green")
-        self.layout: Layout = layout
-        self.scroll = Vector2(0, 0)
-        if not self.layout:
-            self.layout = Column()
-        self.layout.set_parent(self)
-        self.add(*children)
-
-    def get_min_required_size(self):
-        if self.layout:
-            return self.layout.get_auto_size()
-        return self.rect.size
-
-    def reset_scroll(self) -> Self:
-        self.scroll.update(0, 0)
-        self.dirty_children = True
-        return self
-
-    def set_scroll(self, value: tuple) -> Self:
-        self.scroll.update(value)
-        self.dirty_children = True
-        return self
-
-    def scrollX_by(self, x: float | int) -> Self:
-        self.scroll.x += x
-        self.dirty_children = True
-        return self
+        self.surface = None
+        self.layout :Layout = layout
+        if self.layout : self.layout.set_parent(self)
+        for child in children:
+            self.add_child(child)
 
-    def scrollY_by(self, y: float | int) -> Self:
-        self.scroll.y += y
-        self.dirty_children = True
-        return self
-
-    def scroll_by(self, value: tuple[float | int, float | int]) -> Self:
-        self.scroll += value
-        self.dirty_children = True
-        return self
-
-    def set_layout(self, layout: Layout) -> Self:
-        tmp = self.layout
+    def set_layout(self,layout:Layout)->Self:
         self.layout = layout
-        if self.layout != tmp:
-            self.dirty_children = True
+        self.apply_constraints()
         return self
 
-
-    def get_debug_outlines(self):
-        yield (self.rect, self.debug_color)
-        yield (self.get_padded_rect(), self.debug_color)
-
+    def get_bounding_box(self):
+        yield (self.rect,self._debug_color)
         for child in self.children:
-            yield from child.get_debug_outlines()
-            # for data in child.get_debug_outlines():
-
-    def get_interactive_children(self) -> list[InteractiveWidget]:
-        return [
-            child for child in self.children if isinstance(child, InteractiveWidget) and child.allow_focus_to_self()
-        ]
-
-    def focus_next_child(self) -> None:
-        self.layout.focus_next_child()
-        
-    def focus_prev_child(self) -> None:
-        self.layout.focus_prev_child()
+            yield from child.get_bounding_box()
 
-    def clear_children(self) -> None:
+    def clear_children(self)->None:
         self.children.clear()
-        self.dirty_children = True
-
-    def add(self, *child: Widget) -> Self:
-        super().add(*child)
-        self.dirty_children = True
-        return self
-
-    def remove(self, *child: Widget) -> Self:
-        super().remove(*child)
-        self.dirty_children = True
-        return self
-
-    def resolve_constraints(self) -> None:
-        super().resolve_constraints()
-
-    def __str__(self) -> str:
-        return f"Container({self.uid},{len(self.children)})"
-
-    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_focus(self) -> bool:
-        res = super().get_focus()
-        if not res:
-            return False
-        l = l = self.get_interactive_children()
-        if not l:
-            return True
-        self.focused_index = min(self.focused_index, len(l))
-        return l[self.focused_index].get_focus()
-
-    def set_focused_child(self, child: InteractiveWidget) -> bool:
-        l = self.get_interactive_children()
-        i = l.index(child)
-        if i >= 0:
-            self.focused_index = i
-            return True
-        return False
-
-    def allow_focus_to_self(self) -> bool:
-        return len(self.get_interactive_children()) != 0
-
-    def draw(self, camera: bf.Camera) -> None:
-        constraints_down = False
-        if self.dirty_shape:
-            self.dirty_constraints = True
-            self.dirty_children = True
-            self.dirty_surface = True
-            self.build()
-            for child in self.children:
-                child.dirty_constraints = True
-            self.dirty_shape = False
-
-        if self.dirty_constraints:
-            if self.parent and self.parent.dirty_constraints:
-                self.parent.visit_up(self.selective_up)
-            else:
-                constraints_down = True
-
-        if self.dirty_children:
-            if self.layout:
-                self.layout.arrange()
-            self.dirty_children = False
-
-        if constraints_down:
-            self.visit(lambda c: c.resolve_constraints())
-
-        if self.dirty_surface:
-            self.paint()
-            self.dirty_surface = False
+        self.apply_constraints()
 
+    def add_child(self,*child:Widget)->None:
+        super().add_child(*child)
+        if self.layout : self.layout.arrange()
 
-        bf.Entity.draw(self, camera)
+    def remove_child(self,child:Widget)->None:
+        super().remove_child(child)
+        if self.layout : self.layout.arrange()
 
-        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)
-        # Draw children with adjusted positions
-        _ = [child.draw(camera) for child in sorted(self.children, key=lambda c: c.render_order)]
+    def build(self)->None:
+        super().build()
+        if self.layout : self.layout.arrange()
 
-        if self.clip_children:
-            camera.surface.set_clip(old_clip)
+    def apply_constraints(self)->None:
+        super().apply_constraints()
+        if self.layout : self.layout.arrange()
 
+    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,128 +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.add_tags("debugger")
-        self.set_visible(False)
-
-    # def get_debug_outlines(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.set_render_order(99)
-        self.update_text()
-        return self
-
-    def set_text(self, text: str) -> Self:
-        return super().set_text(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("debug_mode") != bf.debugMode.DEBUGGER:
-            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()
-
-
-    def __str__(self)->str:
-        return "Debugger"
-    # def top_at(self,x,y):
-        # return None
-
-class FPSDebugger(Debugger):
-    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
-        self.add_dynamic("FPS", lambda: str(round(manager_link.get_fps())))
-
-
-class BasicDebugger(FPSDebugger):
-    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
-        self.add_dynamic(
-            "Resolution", lambda: "x".join(str(i) for i in bf.const.RESOLUTION)
-        )
-        super().do_when_added()
-        parent_scene = self.parent_scene
-
-        self.add_dynamic("Mouse", pygame.mouse.get_pos)
-        self.add_dynamic(
-            "World",
-            lambda: convert_to_int(
-                *parent_scene.camera.screen_to_world(pygame.mouse.get_pos())
-            ),
-        )
-        self.add_dynamic(
-            "Hud",
-            lambda: convert_to_int(
-                *parent_scene.hud_camera.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())
-
-        self.add_dynamic("Hover",lambda : str(parent_scene.root.hovered) if parent_scene.root.hovered else None)
+	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

@@ -0,0 +1,19 @@
+import batFramework as bf
+from .shape import Shape
+import pygame
+
+
+class Frame(Shape):
+    def __init__(self,width:float,height:float):
+        super().__init__(width,height)
+        self.set_debug_color("magenta")
+
+    def to_string_id(self)->str:
+        return "Frame"
+
+    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()

batFramework/gui/image.py

@@ -1,47 +1,23 @@
 import batFramework as bf
 from .widget import Widget
 import pygame
-from typing import Self
-
-
 class Image(Widget):
-    def __init__(
-        self,
-        path: str = None,
-        convert_alpha=True,
-    ):
-        self.original_surface = None
-        super().__init__(convert_alpha = convert_alpha)
-        if path is not None:
-            self.from_path(path)
-
-    def paint(self) -> None:
-        super().paint()
-        self.surface.fill((0,0,0,0 if self.convert_alpha else 255))
-        if self.rect.size != self.original_surface.get_size():
-            self.surface.blit(pygame.transform.scale(self.original_surface,self.rect.size),(0,0))
-        else:
-            self.surface.blit(self.original_surface,(0,0))
-
+	def __init__(self,data:pygame.Surface|str,size:None|tuple[int,int]=None,convert_alpha=True):
+		super().__init__(False)
+		self.surface = None
+		if isinstance(data,str):
+			path = bf.utils.get_path(data)
+			self.original_surface=pygame.image.load(path)
+		elif isinstance(data,pygame.Surface):
+			self.original_surface = data
+			
+		if convert_alpha:	self.original_surface = self.original_surface.convert_alpha()
+		if not size : size = self.original_surface.get_size()
+		self.set_size(*size)
 
-    def from_path(self,path:str)->Self:
-        tmp = bf.ResourceManager().get_image(path,self.convert_alpha)
-        if tmp is None:
-            return self
-        self.original_surface = tmp
-        size = self.original_surface.get_size()
-        if not self.autoresize_h : size[0] = None
-        if not self.autoresize_h : size[1] = None
-        self.set_size(size)
-        self.dirty_surface = True
-        return self
 
-    def from_surface(self,surface: pygame.Surface)->Self:
-        if surface is None : return self
-        self.original_surface = surface
-        size = self.original_surface.get_size()
-        if not self.autoresize_h : size[0] = None
-        if not self.autoresize_h : size[1] = None
-        self.set_size(size)
-        self.dirty_surface = True
-        return self
+	def build(self)->None:
+		if not self.surface or self.surface.get_size() != self.get_size_int():
+			self.surface = pygame.transform.scale(self.original_surface,self.get_size_int())
+			
+