batframework 1.1.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

batFramework/gui/container.py

@@ -1,49 +1,220 @@
-import batFramework as bf
-from .widget import Widget
-from .layout import Layout
-from .constraints import Constraint
-from typing import Self
-
-class Container(Widget):
-    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)
-        for child in children:
-            self.add_child(child)
-
-    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)
-        for child in self.children:
-            yield from child.get_bounding_box()
-
-    def clear_children(self)->None:
-        self.children.clear()
-        self.apply_constraints()
-
-    def add_child(self,*child:Widget)->None:
-        super().add_child(*child)
-        if self.layout : self.layout.arrange()
-
-    def remove_child(self,child:Widget)->None:
-        super().remove_child(child)
-        if self.layout : self.layout.arrange()
-
-    def build(self)->None:
-        super().build()
-        if self.layout : self.layout.arrange()
-
-    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]})"
-    
+import pygame
+import batFramework as bf
+from .widget import Widget
+from .shape import Shape
+from .interactiveWidget import InteractiveWidget
+from .layout import Layout, Column
+from typing import Self
+from pygame.math import Vector2
+
+
+class Container(Shape, InteractiveWidget):
+    def __init__(self, layout: Layout = None, *children: Widget) -> None:
+        super().__init__()
+        self.dirty_layout: bool = False
+        self.layout = layout if layout else Column()
+        self.layout.set_parent(self)
+        self.scroll = Vector2(0, 0)
+        self.dirty_scroll = False
+        self.set_debug_color("green")
+        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.set_scroll((0, 0))
+        return self
+
+    def set_scroll(self, value: tuple[float]) -> Self:
+        # print("Trying to set scroll to ",value)
+        # print("Current scroll is : ",self.scroll)
+
+        if (self.scroll.x,self.scroll.y) == value:
+            return self
+        self.scroll.update(value)
+        # print("Scroll updated to", value)
+        self.clamp_scroll()
+        self.dirty_scroll = True
+        # self.dirty_layout = True
+        return self
+
+    def scrollX_by(self, x: float) -> Self:
+        if x == 0:
+            return self
+        self.set_scroll((self.scroll.x + x, self.scroll.y))
+        return self
+
+    def scrollY_by(self, y: float) -> 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]) -> 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()
+
+        if self.layout:
+            # self.layout.update_children_rect()
+            children_rect = self.layout.children_rect 
+        else:
+            l = self.get_layout_children()
+            if l:
+                children_rect = l[0].rect.unionall(
+                    [c.rect for c in l[1:]]
+                ) if len(l) > 1 else l
+            else:
+                children_rect = pygame.Rect(0,0,0,0)
+
+        max_scroll_x = max(0, children_rect.width - r.width)
+        max_scroll_y = max(0, children_rect.height - r.height)
+
+        sx = min(max(self.scroll.x, 0), max_scroll_x)
+        sy = min(max(self.scroll.y, 0), max_scroll_y)
+        # print("_"*20)
+        # print("Clamping scroll, children rect is :",children_rect)
+        # print("scroll to,",(sx,sy), "while current scroll is",self.scroll)
+        
+        self.set_scroll((sx,sy))
+        
+        return self
+
+    def set_layout(self, layout: Layout) -> Self:
+        tmp = self.layout
+        self.layout = layout
+        if self.layout != tmp:
+            tmp.set_parent(None)
+            self.layout.set_parent(self)
+            self.reset_scroll()
+            self.dirty_layout = True
+        return self
+
+    def get_interactive_children(self) -> list[InteractiveWidget]:
+        """Return all children that can be cycled through with focus"""
+        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]:
+        """Returns all children affected by layout"""
+        return self.children
+
+    def clear_children(self) -> None:
+        for child in self.children:
+            child.set_parent(None)
+        self.children.clear()
+        self.dirty_layout = True
+
+    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 children_has_focus(self)->bool:
+        """Return true if any direct children is focused"""
+        return any(child.is_focused for child in self.get_interactive_children())
+
+    def handle_event(self, event) -> None:
+        super().handle_event(event) 
+        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 whether the container can get focused"""
+        return bool(self.get_interactive_children()) and self.visible
+    
+    def build(self) -> None:
+        if self.layout is not None:
+            size = self.layout.get_auto_size()
+            self.set_size(self.resolve_size(size))
+        super().build()
+
+
+    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
+
+        if self.dirty_scroll:
+            self.layout.scroll_children()
+            self.dirty_scroll = False
+
+    def apply_post_updates(self,skip_draw:bool=False):
+        if self.dirty_shape:
+            self.layout.update_child_constraints()
+            self.build()
+            self.dirty_size_constraints = True
+            self.dirty_position_constraints = True
+            self.dirty_layout =  True
+            from .container import Container
+            if self.parent and isinstance(self.parent, Container):
+                self.parent.dirty_layout = True
+                self.parent.dirty_shape = True
+            self.dirty_shape = False
+            self.dirty_surface = True
+
+        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
+
+

batFramework/gui/debugger.py

@@ -1,47 +1,140 @@
-from .label import Label
-from typing import Self
-
-class Debugger(Label):
-	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()
+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]
+
+
+class Debugger(Label):
+    def __init__(self) -> None:
+        super().__init__("")
+        self.root_link = None
+        self.static_data: dict[str,Any] = {}
+        self.dynamic_data: dict[str,Callable[[],str]] = {}
+        self.refresh_interval :float = .01
+        self.refresh_counter: float = 0
+        self.add_tags("debugger")
+        self.set_visible(False)
+    
+
+    def set_parent(self, parent):
+        super().set_parent(parent)
+        self.root_link = self.get_root()
+        
+    def set_refresh_rate(self, value: float) -> Self:
+        """
+        seet refresh interval, time in seconds between each refresh of the debugger
+        """
+        self.refresh_interval = value
+        self.refresh_counter = 0
+        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
+        
+        if self.refresh_counter > self.refresh_interval:
+            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 self.root_link is None:
+            return
+        
+
+        self.add_dynamic(
+            "Hover",
+            lambda: (
+                str(self.root_link.hovered) if self.root_link.hovered else None
+            ),
+        )
+

batFramework/gui/draggableWidget.py

@@ -0,0 +1,63 @@
+from .interactiveWidget import InteractiveWidget
+import batFramework as bf
+import pygame
+
+
+class DraggableWidget(InteractiveWidget):
+    def __init__(self, *args, **kwargs) -> None:
+        self.drag_start = None
+        self.offset = None
+        self.click_mask = [True,False,False,False,False]
+        self.is_dragged : bool = False # the widget is following the mouse AND the mouse is in the widget
+        self.is_dragged_outside : bool = False # the widget is following the mouse BUT the mouse is NOT in the widget
+        super().__init__(*args, **kwargs)
+    
+    def set_click_mask(self,b1=0,b2=0,b3=0,b4=0,b5=0):
+        self.click_mask = [b1,b2,b3,b4,b5]
+
+    
+    def do_on_drag(
+        self, drag_start_pos: tuple[float, float], drag_end_pos: tuple[float, float]
+    ) -> None:
+        
+        new_pos = drag_end_pos[0] - self.offset[0], drag_end_pos[1] - self.offset[1]
+        if self.rect.topleft != new_pos:
+
+            self.set_position(*new_pos)
+
+    def on_click_down(self, button, event=None):
+        if button < 1 or button > 5 :
+            return
+        self.is_clicked_down[button-1] = True
+        self.is_dragged = any(i==j and i== True for i,j in zip(self.is_clicked_down,self.click_mask))
+        if self.is_dragged:
+            event.consumed = True
+        self.do_on_click_down(button,event)
+
+    def on_click_up(self, button, event=None):
+        if button < 1 or button > 5 :
+            return
+        self.is_clicked_down[button-1] = False
+        self.is_dragged = any(i==j and i== True for i,j in zip(self.is_clicked_down,self.click_mask))
+        self.do_on_click_up(button,event)
+
+    def update(self, dt: float):
+        super().update(dt)
+        self.is_dragged_outside = any(i==j and i== True for i,j in zip(pygame.mouse.get_pressed(5),self.click_mask))
+
+
+        if self.is_dragged and self.is_dragged_outside:
+            x, y = self.parent_layer.camera.get_mouse_pos()
+            if self.drag_start == None:
+                self.offset = x - self.rect.x, y - self.rect.y
+                self.drag_start = x, y
+            else:
+                self.do_on_drag(self.drag_start, (x, y))
+                
+        else:
+            self.drag_start = None
+            self.offset = None
+            self.is_clicked_down = [False]*5
+        
+        if not self.is_dragged_outside:
+            self.is_dragged = False

batFramework/gui/image.py

@@ -1,23 +1,61 @@
-import batFramework as bf
-from .widget import Widget
-import pygame
-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())
-			
-            
+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_shape = True
+        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_shape = True
+
+        self.dirty_surface = True
+        return self