batframework 1.0.9a11__py3-none-any.whl → 1.0.10__py3-none-any.whl

batFramework/gui/container.py

@@ -1,206 +1,49 @@
-import pygame
 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
-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_layout: bool = False
         self.set_debug_color("green")
-        self.layout = layout if layout else Column()
-        self.layout.set_parent(self)
-        self.scroll = Vector2(0, 0)
-        self.add(*children)
-
-    def __str__(self) -> str:
-        return f"Container({self.uid},{len(self.children)})"
-
-    def get_min_required_size(self):
-        return self.layout.get_auto_size() if self.layout else self.rect.size
-
-    def reset_scroll(self) -> Self:
-        if self.scroll == (0,0):
-            return self
-        self.scroll.update(0, 0)
-        self.dirty_layout = True
-        return self
-
-    def set_scroll(self, value: tuple) -> Self:
-        if (self.scroll.x,self.scroll.y) == value:
-            return self
-        self.scroll.update(value)
-        self.clamp_scroll()
-        self.dirty_layout = True
-        return self
-
-    def scrollX_by(self, x: float | int) -> Self:
-        if x == 0:
-            return self
-        self.set_scroll((self.scroll.x + x, self.scroll.y))
-        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:
-        if y == 0:
-            return self
-        self.set_scroll((self.scroll.x, self.scroll.y + y))
-        return self
-
-    def scroll_by(self, value: tuple[float | int, float | int]) -> Self:
-        if value[0] == 0 and value[1] == 0:
-            return self
-        self.set_scroll((self.scroll.x + value[0], self.scroll.y + value[1]))
-        return self
-
-    def clamp_scroll(self) -> Self:
-        if not self.children:
-            return self
-        r = self.get_inner_rect()
-        # Compute the bounding rect of all children in one go
-        children_rect = self.children[0].rect.copy()
-        for child in self.children[1:]:
-            children_rect.union_ip(child.rect)
-        max_scroll_x = max(0, children_rect.width - r.width)
-        max_scroll_y = max(0, children_rect.height - r.height)
-
-        # Clamp scroll values only if needed
-        new_x = min(max(self.scroll.x, 0), max_scroll_x)
-        new_y = min(max(self.scroll.y, 0), max_scroll_y)
-
-        self.set_scroll((new_x, new_y))
-        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:
-            tmp.set_parent(None)
-            self.layout.set_parent(self)
-            self.reset_scroll()
-            self.dirty_layout = True
+        self.apply_constraints()
         return self
 
-    def get_interactive_children(self) -> list[InteractiveWidget]:
-        return [child for child in self.get_layout_children() if isinstance(child, InteractiveWidget) and not isinstance(child,Container) and child.allow_focus_to_self()]
-
-    def get_layout_children(self)->list[Widget]:
-        return self.children
+    def get_bounding_box(self):
+        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.dirty_layout = True
+        self.apply_constraints()
 
-    def add(self, *child: Widget) -> Self:
-        super().add(*child)
-        self.dirty_shape = True
-        self.dirty_layout = True
-        return self
-
-    def remove(self, *child: Widget) -> Self:
-        super().remove(*child)
-        self.dirty_shape = True
-        self.dirty_layout = True
-        return self
-
-    def top_at(self, x: float | int, y: float | int) -> "None|Widget":
-        if self.rect.collidepoint(x, y):
-            for child in reversed(self.children):
-                result = child.top_at(x, y)
-                if result is not None:
-                    return result
-            return self
-        return None
-
-    def get_focus(self) -> bool:
-        if not super().get_focus():
-            return False
-        interactive_children = self.get_interactive_children()
-        if not interactive_children:
-            return True
-        self.focused_index = min(self.focused_index, len(interactive_children) - 1)
-        return interactive_children[self.focused_index].get_focus()
+    def add_child(self,*child:Widget)->None:
+        super().add_child(*child)
+        if self.layout : self.layout.arrange()
 
-    def children_has_focus(self)->bool:
-        return any(child.is_focused for child in self.get_interactive_children())
+    def remove_child(self,child:Widget)->None:
+        super().remove_child(child)
+        if self.layout : self.layout.arrange()
 
-    def do_handle_event(self, event) -> None:
-        super().do_handle_event(event)
-        if event.type == pygame.MOUSEWHEEL:
-            # Adjust scroll based on the mouse wheel movement
-            scroll_speed = 20  # Adjust this value to control the scroll speed
-            self.scroll_by((0, -event.y * scroll_speed))  # Scroll vertically
-            event.consumed = True  # Mark the event as consumed
-        self.layout.handle_event(event)
-
-    def set_focused_child(self, child: InteractiveWidget) -> bool:
-        interactive_children = self.get_interactive_children()
-        try:
-            index = interactive_children.index(child)
-            self.focused_index = index
-            if self.layout : 
-                self.layout.scroll_to_widget(child)
-            return True
-        except ValueError:
-            return False
-
-    def allow_focus_to_self(self) -> bool:
-        return bool(self.get_interactive_children()) and self.visible
-    
-    def build(self) -> None:
-        if self.layout is not None:
-            # print("I'm building !",self)
-            # size = self.expand_rect_with_padding((0,0,*self.layout.get_auto_size())).size
-            size = self.layout.get_auto_size()
-            self.set_size(self.resolve_size(size))
+    def build(self)->None:
         super().build()
+        if self.layout : self.layout.arrange()
 
-    def apply_pre_updates(self):
-        if self.dirty_size_constraints or self.dirty_shape:
-            self.resolve_constraints(size_only=True)
-            self.dirty_size_constraints = False
-            self.dirty_position_constraints = True
-
-        if self.dirty_layout:
-            self.layout.update_child_constraints()
-            self.layout.arrange()
-            self.dirty_layout = False
-
-    def apply_post_updates(self,skip_draw:bool=False):
-        """
-        BOTTOM TO TOP
-        for cases when widget attributes depend on children attributes
-        """
-        if self.dirty_shape:
-            self.layout.update_child_constraints()
-            self.build()
-            self.dirty_shape = False
-            self.dirty_surface = True
-            self.dirty_layout =  True
-            self.dirty_size_constraints = True
-            self.dirty_position_constraints = True
-            from .container import Container
-            if self.parent and isinstance(self.parent, Container):
-                self.parent.dirty_layout = True
-                self.parent.dirty_shape = True
-
-            # trigger layout or constraint updates in parent
-            
-
-            # force recheck of constraints
-
-
-        if self.dirty_position_constraints:
-            self.resolve_constraints(position_only=True)
-            self.dirty_position_constraints= False
-
-
-        if self.dirty_surface and not skip_draw:
-            self.paint()
-            self.dirty_surface = False
-
+    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,130 +1,47 @@
 from .label import Label
-from typing import Self,Callable,Any
-import batFramework as bf
-import pygame
-import sys
-
-
-def convert_to_int(*args):
-    return [int(arg) for arg in args]
-
+from typing import Self
 
 class Debugger(Label):
-    def __init__(self) -> None:
-        super().__init__("")
-        self.static_data: dict[str,Any] = {}
-        self.dynamic_data: dict[str,Callable[[],str]] = {}
-        self.refresh_rate = 10
-        self.refresh_counter: float = 0
-        self.add_tags("debugger")
-        self.set_visible(False)
-
-    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:Callable[[],str]) -> None:
-        self.dynamic_data[key] = func
-        self.update_text()
-
-    def remove_static(self, key:str) -> bool:
-        try:
-            self.static_data.pop(key)
-            return True
-        except KeyError:
-            return False
-
-    def remove_dynamic(self, key:str) -> 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(sys.maxsize-100)
-        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 bf.ResourceManager().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 __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
-        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()
-        self.add_dynamic("Mouse", pygame.mouse.get_pos)
-
-        if not hasattr(self.parent_scene,"root"):
-            print("Debugger couldn't find 'root' widget in parent scene")
-            return
+	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()
         
-        parent_scene = self.parent_scene
-
-        self.add_dynamic(
-            "Hover",
-            lambda: (
-                str(parent_scene.root.hovered) if parent_scene.root.hovered else None
-            ),
-        )
+	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,58 +1,23 @@
 import batFramework as bf
 from .widget import Widget
-from .shape import Shape
 import pygame
-from typing import Self
-
-
-class Image(Shape):
-    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 __str__(self) -> str:
-        return "Image"
-
-    def paint(self) -> None:
-        super().paint()
-        if self.original_surface is None:
-            return
-        padded = self.get_inner_rect().move(-self.rect.x,-self.rect.y)
-        target_size = padded.size
-        if self.original_surface.get_size() != target_size:
-            self.surface.blit(pygame.transform.scale(self.original_surface, target_size), padded.topleft)
-        else:
-            self.surface.blit(self.original_surface, padded.topleft)
-
-    def build(self) -> None:
-        if self.original_surface is not None:
-            self.set_size(
-                self.expand_rect_with_padding((0,0,*self.original_surface.get_size())).size
-            )
-        super().build()
-
-
-    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()
-        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()
-        self.set_size(size)
-        self.dirty_surface = True
-        return self
+class Image(Widget):
+	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 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())
+			
+            

batFramework/gui/indicator.py

@@ -1,113 +1,40 @@
 from .shape import Shape
-from typing import Any, Self, Callable
+from typing import Any
 import pygame
-from .widget import Widget
-from .interactiveWidget import InteractiveWidget
-from .draggableWidget import DraggableWidget
-import batFramework as bf
-
+# from .constraints import ConstraintAspectRatio
 
 class Indicator(Shape):
-    """
-    Shape intended to be used as icons/indicators
-    due to its nature, it overrides the top_at function (it can not be 'seen' by the mouse)
-    
-    """
-    
-    def __init__(self, size: tuple[int | float] = (10, 10)) -> None:
-        super().__init__(size)
-        self.debug_color = "magenta"
-        self.set_outline_width(1)
-        self.set_outline_color("black")
+    def __init__(self,width:int|float= 10,height:int|float=10)->None:
+        super().__init__(width,height)
 
-    def to_string_id(self) -> str:
+    def to_string_id(self)->str:
         return "Indicator"
 
-    def set_value(self, value: Any) -> None:
+    def set_value(self,value:Any)->None:
         pass
 
-    def get_value(self) -> Any:
+    def get_value(self)->Any:
         pass
 
-    def top_at(self, x, y):
-        return None
+    def _build_indicator(self)->None:
+        pass
+    
+    def build(self)->None:
+        super().build()
+        self._build_indicator()
 
 
 class ToggleIndicator(Indicator):
-    def __init__(self, default_value: bool) -> None:
-        super().__init__((20, 20))
-        self.value: bool = default_value
-        self.callback = lambda val: self.set_color("green" if val else "red")
-        self.set_value(default_value)
-        self.callback(default_value)
-        # TODO aspect ratio would be good right about here
-        self.add_constraints(bf.gui.AspectRatio(1,reference_axis=bf.axis.VERTICAL))
-
-    def set_callback(self, callback : Callable[[bool],Any]) -> Self:
-        self.callback = callback
-        return self
+    def __init__(self,default_value:bool)->None:
+        self.value:bool = default_value
+        super().__init__(20,20)
+        # self.add_constraint(ConstraintAspectRatio(1))
 
-    def set_value(self, value: bool) -> None:
+    def set_value(self,value)->None:
         self.value = value
-        if self.callback:
-            self.callback(value)
-        self.dirty_surface = True
+        self.set_color("green" if value else "red")
+        self.build()
 
-    def get_value(self) -> bool:
+    def get_value(self)->bool:
         return self.value
-
-    def top_at(self, x: float, y: float) -> "None|Widget":
-        r = super().top_at(x, y)
-        if r is self:
-            return None
-        return r
-
-class ArrowIndicator(Indicator):
-    def __init__(self,direction:bf.direction):
-        super().__init__()
-        self.direction : bf.direction = direction
-        self.arrow_color = bf.color.WHITE
-        self.line_width : int = 1
-
-    def set_arrow_color(self,color)-> Self:
-        self.arrow_color = color
-        self.dirty_surface = True
-        return self
-
-    def set_arrow_direction(self,direction:bf.direction)->Self:
-        self.direction = direction
-        self.dirty_surface = True
-        return self
-
-    def set_arrow_line_width(self,value:int)->Self:
-        self.line_width = value
-        self.dirty_surface = True
-        return self
-        
-    def paint(self):
-        super().paint()
-        r = self.get_local_inner_rect()
-        size = min(r.width, r.height)
-        if size %2 == 0:
-            size -= 1
-        r.width = size
-        r.height = size
-
-        #pixel alignment
-        if (self.padding[1]+self.padding[3] )%2 ==0:
-            r.height-=1
-        if (self.padding[0]+self.padding[2] )%2 ==0:
-            r.width-=1
-        r.center = self.get_local_inner_rect().center
-
-        bf.utils.draw_triangle(
-            surface = self.surface,
-            color = self.arrow_color,
-            rect =r,
-            direction = self.direction,
-            width = self.line_width
-
-        )
-        
-
-
+#