batframework 0.1.13__py3-none-any.whl → 1.0.1__py3-none-any.whl

batFramework/gui/image.py

@@ -1,23 +1,43 @@
 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 __init__(
+        self,
+        data: pygame.Surface | str | None = None,
+        size: None | tuple[int, int] = None,
+        convert_alpha=True,
+    ):
+        self.dirty : bool = False
+        self.original_surface = None
+        self.surface = None
+        super().__init__(convert_alpha)
+        if data:
+            self.set_image(data,size)
 
+    def build(self) -> None:
+        if self.original_surface and (
+            (not self.surface or self.surface.get_size() != self.get_size_int()) 
+            or self.dirty
+        ) :
+            self.surface = pygame.transform.scale(
+                self.original_surface, self.get_size_int()
+            )
 
-	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())
-			
-            
+    def set_image(
+        self, data: pygame.Surface | str, size: None | tuple[int, int] = None
+    ):
+        if isinstance(data, str):
+            path = bf.utils.get_path(data)
+            tmp = pygame.image.load(path)
+        elif isinstance(data, pygame.Surface):
+            tmp= data
+        if self.convert_alpha:
+            tmp = tmp.convert_alpha()
+        if tmp != self.original_surface: self.dirty = True
+        self.original_surface = tmp
+        if not size:
+            size = self.original_surface.get_size()
+        self.set_size(*size)

batFramework/gui/indicator.py

@@ -1,42 +1,46 @@
 from .shape import Shape
 from typing import Any
 import pygame
+
 # from .constraints import ConstraintAspectRatio
 
+
 class Indicator(Shape):
-    def __init__(self,width:int|float= 10,height:int|float=10)->None:
-        super().__init__(width,height)
+    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 _build_indicator(self)->None:
+    def _build_indicator(self) -> None:
         pass
-    
-    def build(self)->None:
+
+    def build(self) -> None:
         super().build()
         self._build_indicator()
 
 
 class ToggleIndicator(Indicator):
-    def __init__(self,default_value:bool)->None:
-        self.value:bool = default_value
-        super().__init__(20,20)
+    def __init__(self, default_value: bool) -> None:
+        self.value: bool = default_value
+        super().__init__(20, 20)
+
+        #TODO aspect ratio would be good right about here
         # self.add_constraint(ConstraintAspectRatio(1))
 
-    def set_value(self,value)->None:
+    def set_value(self, value) -> None:
         self.value = value
         self.set_color("green" if value else "red")
         self.build()
 
-    def get_value(self)->bool:
-        return self.value 
+    def get_value(self) -> bool:
+        return self.value
 
     def top_at(self, x: float, y: float) -> "None|Widget":
         return None

batFramework/gui/interactiveWidget.py

@@ -1,22 +1,23 @@
 from .widget import Widget
 
+
 class InteractiveWidget(Widget):
-    def __init__(self,*args,**kwargs):
-        super().__init__(convert_alpha = True)
+    def __init__(self, *args, **kwargs):
+        super().__init__(convert_alpha=True)
         self.focusable = True
-        self.is_focused : bool = False
+        self.is_focused: bool = False
 
-    def get_focus(self)->bool:
-        if self.parent is None or not self.focusable: return False
+    def get_focus(self) -> bool:
+        if self.parent is None or not self.focusable:
+            return False
         self.get_root().focus_on(self)
 
-    def on_get_focus(self)->None:
+    def on_get_focus(self) -> None:
         self.is_focused = True
 
-    def on_lose_focus(self)->None:
+    def on_lose_focus(self) -> None:
         self.is_focused = False
-        
-    def lose_focus(self)->bool:
+
+    def lose_focus(self) -> bool:
         if self.is_focused and self.parent is not None:
             self.get_root().focus_on(None)
-            

batFramework/gui/label.py

@@ -10,21 +10,21 @@ class Align(Enum):
     CENTER = 3
 
 class Label(Shape):
-    def __init__(self,text:str) -> None:   
+    def __init__(self, text: str) -> None:
         self._text = ""
 
-        self._resized_flag : bool = False
+        self._resized_flag: bool = False
 
         # Enable/Disable antialiasing
-        self._antialias : bool = True
-        
-        self._text_size = bf.const.DEFAULT_TEXT_SIZE
+        self._antialias: bool = True
 
-        self.auto_wraplength:bool = False
+        self._text_size = bf.FontManager().DEFAULT_TEXT_SIZE
 
-        self._alignment : Align = Align.CENTER
-        
-        self._text_color : tuple[int,int,int]|str = "black"
+        self.auto_wraplength: bool = False
+
+        self._alignment: Align = Align.CENTER
+
+        self._text_color: tuple[int, int, int] | str = "black"
         # font name (given when loaded by utils) to use for the text
         self._font_name = None
         # reference to the font object
@@ -32,96 +32,102 @@ class Label(Shape):
         # Rect containing the text of the label
         self._text_rect = None
         # text surface (result of font.render)
-        self._text_surface : pygame.Surface | None= None 
-        super().__init__(width=0,height=0)
-        self.set_padding((10,4))
+        self._text_surface: pygame.Surface | None = None
+        super().__init__(width=0, height=0)
+        self.set_padding((10, 4))
         self.set_debug_color("blue")
         self.set_color(bf.color.CLOUD_WHITE)
         self.set_autoresize(True)
         self.set_font(force=True)
         self.set_text(text)
 
-    def set_text_color(self,color)->Self:
+    def set_text_color(self, color) -> Self:
         self._text_color = color
         self.build()
         return self
 
-    def to_string_id(self)->str:
+    def to_string_id(self) -> str:
         return f"Label({self._text})"
 
-    def set_align(self,alignment:Align)->"Label":
+    def set_align(self, alignment: Align) -> "Label":
         self._alignment = alignment
-        self.build() 
+        self.build()
         return self
 
-    def set_auto_wraplength(self,val:bool)->"Label":
+    def set_auto_wraplength(self, val: bool) -> "Label":
         self.auto_wraplength = val
         self.build()
         return self
 
     def get_bounding_box(self):
         yield from super().get_bounding_box()
-        if self._text_rect : yield self._text_rect.move(*self.rect.topleft)
+        if self._text_rect:
+            yield self._text_rect.move(*self.rect.topleft)
 
-    def set_font(self,font_name:str=None,force:bool = False)-> "Label":
-        if font_name == self._font_name and not force: return self
+    def set_font(self, font_name: str = None, force: bool = False) -> "Label":
+        if font_name == self._font_name and not force:
+            return self
         self._font_name = font_name
-        self._font_object = bf.utils.get_font(self._font_name,self._text_size)
+        self._font_object = bf.FontManager().get_font(self._font_name, self._text_size)
         self.build()
         return self
 
-    def set_text_size(self,text_size:int) -> "Label":
-        text_size = round(text_size/2) * 2
-        if text_size == self._text_size : return self
+    def set_text_size(self, text_size: int) -> "Label":
+        text_size = round(text_size / 2) * 2
+        if text_size == self._text_size:
+            return self
         self._text_size = text_size
-        self._font_object = bf.utils.get_font(self._font_name,self._text_size)
+        self._font_object = bf.FontManager().get_font(self._font_name, self._text_size)
         self.build()
         return self
 
-    def get_text_size(self)-> int:
+    def get_text_size(self) -> int:
         return self._text_size
 
-    def is_antialias(self)->bool:
+    def is_antialias(self) -> bool:
         return self._antialias
 
-    def set_antialias(self,value:bool)->"Label":
+    def set_antialias(self, value: bool) -> "Label":
         self._antialias = value
         self.build()
         return self
 
-    def set_text(self,text:str) -> "Label":
-        if text == self._text : return self
+    def set_text(self, text: str) -> "Label":
+        if text == self._text:
+            return self
         self._text = text
         self.build()
         return self
-    
-    def get_text(self)->str:
+
+    def get_text(self) -> str:
         return self._text
 
 
-    def _build_text(self)-> None:
+    def get_min_required_size(self)->tuple[float,float]:
+        return (0,0) if not self._font_object else self.inflate_rect_by_padding(pygame.FRect(0,0,*self._font_object.size(self._text))).size
+
+    def _build_text(self) -> None:
         if self._font_object is None:
             print(f"No font for '{self.to_string_id()}' :(")
             return
         # render(text, antialias, color, bgcolor=None, wraplength=0) -> Surface
         self._text_surface = self._font_object.render(
-            text        = self._text,
-            antialias   = self._antialias,
-            color       = self._text_color,
-            bgcolor     = self._color,
-            wraplength  = int(self.get_content_width()) if self.auto_wraplength else 0 
+            text=self._text,
+            antialias=self._antialias,
+            color=self._text_color,
+            bgcolor=self._color,
+            wraplength=int(self.get_content_width()) if self.auto_wraplength else 0,
         )
-        
+
         self._text_rect = self._text_surface.get_frect()
 
-    def _build_layout(self)->None:
+    def _build_layout(self) -> None:
+        if not self._text_rect : return
         if self.autoresize:
-            if self.rect.size != self.inflate_rect_by_padding(self._text_rect).size :
-                self.set_size(
-                    self._text_rect.w + self.padding[0]+self.padding[2], 
-                    self._text_rect.h + self.padding[1]+self.padding[3] 
-                )
-                self._resized_flag  = True
+            target_rect = self.inflate_rect_by_padding(self._text_rect)
+            if self.rect.size != target_rect.size:
+                self._resized_flag = True
+                self.set_size(* target_rect.size)
                 return
         if self._alignment == Align.CENTER:
             self._text_rect.center = self.get_content_rect_rel().center
@@ -129,20 +135,18 @@ class Label(Shape):
             self._text_rect.topleft = self.get_content_rect_rel().topleft
         elif self._alignment == Align.RIGHT:
             self._text_rect.topright = self.get_content_rect_rel().topright
-        if self._resized_flag : 
+        if self._resized_flag:
             self._resized_flag = False
-            if self.parent : self.parent.children_modified()
+            if self.parent:
+                # print("Children modified call")
+                self.parent.children_modified()
 
+        self.surface.fblits([(self._text_surface, self._text_rect)])
 
-
-
-        self.surface.blit(self._text_surface,self._text_rect)
-                
-    def build(self)->None:
+    def build(self) -> None:
         super().build()
-        if not self._font_object:return
+        if not self._font_object:
+            return
         self._build_text()
         self._build_layout()
         self.apply_constraints()
-
-

batFramework/gui/layout.py

@@ -4,90 +4,93 @@ from .constraints import *
 from typing import Self
 import pygame
 
+
 class Layout:
-    def __init__(self, parent: Widget=None):
+    def __init__(self, parent: Widget = None):
         self.parent = parent
-        self.child_constraints : list[Constraint] = []
-        
-    def set_child_constraints(self,*constraints)->Self:
-        self.child_constraints = constraints
+        self.child_constraints: list[Constraint] = []
+        self.children_rect = pygame.FRect(0, 0, 0, 0)
+
+    def set_child_constraints(self, *constraints) -> Self:
+        self.child_constraints = list(constraints)
         self.arrange()
         return self
-        
-    def set_parent(self,parent:Widget):
+
+    def set_parent(self, parent: Widget):
         self.parent = parent
         self.arrange()
 
-    def arrange(self)->None:
+    def arrange(self) -> None:
         raise NotImplementedError("Subclasses must implement arrange  method")
 
+
 class Column(Layout):
-    def __init__(self,gap:int=0,shrink:bool=False,center:bool = False):
+    def __init__(self, gap: int = 0, fit_children: bool = True, center: bool = True):
         super().__init__()
         self.gap = gap
-        self.shrink :bool = shrink
+        self.fit_children: bool = fit_children
         self.center = center
-        self.children_rect = pygame.FRect(0,0,0,0)
-
-        
-    def arrange(self)->None:
-        if not self.parent or not self.parent.children : return 
 
+    def arrange(self) -> None:
+        if not self.parent or not self.parent.children:
+            return
         len_children = len(self.parent.children)
-        parent_height = sum(c.rect.h for c in self.parent.children)
-        parent_width = max(c.rect.w for c in self.parent.children)
-        if self.gap  : parent_height += (len_children-1) * self.gap
-        self.children_rect.update(self.parent.get_content_left(),self.parent.get_content_top(), parent_width, parent_height)
-        if self.center : self.children_rect.center = self.parent.rect.center
-        if self.shrink:
-            c = self.parent.get_constraint("height")
-            if not c or c.height != parent_height : 
-                self.parent.add_constraints(ConstraintHeight(parent_height))
-            c = self.parent.get_constraint("width")
-            if not c or c.width != parent_width : 
-                self.parent.add_constraints(ConstraintWidth(parent_width))
+        parent_height = sum(c.get_min_required_size()[1] for c in self.parent.children)
+        parent_width = max(c.get_min_required_size()[0] for c in self.parent.children)
+        if self.gap:
+            parent_height += (len_children - 1) * self.gap
+        self.children_rect.update(
+            self.parent.get_content_left(),
+            self.parent.get_content_top(),
+            parent_width,
+            parent_height,
+        )
+        if self.fit_children:
+            self.parent.set_size(parent_width,parent_height)
+        if self.center:
+            self.children_rect.center = self.parent.rect.center
+
         current_y = self.children_rect.top
 
         for child in self.parent.children:
-            child.set_position(self.parent.rect.x,current_y)
+            child.set_position(self.parent.rect.x, current_y)
             current_y += child.rect.h + self.gap
             for c in self.child_constraints:
-                if not child.has_constraint(c.name):
-                    child.add_constraints(c)
-            
+                child.add_constraints(c)
+
+
 class Row(Layout):
-    def __init__(self, gap: int = 0, shrink: bool = False, center: bool = False):
+    def __init__(self, gap: int = 0, fit_children: bool = True, center: bool = True):
         super().__init__()
         self.gap = gap
-        self.shrink: bool = shrink
+        self.fit_children: bool = fit_children
         self.center = center
-        self.children_rect = pygame.FRect(0, 0, 0, 0)
 
     def arrange(self) -> None:
         if not self.parent or not self.parent.children:
             return
 
         len_children = len(self.parent.children)
-        parent_width = sum(c.rect.w for c in self.parent.children)
-        parent_height = max(c.rect.h for c in self.parent.children)
+        parent_width = sum(c.get_min_required_size()[0] for c in self.parent.children)
+        parent_height = max(c.get_min_required_size()[1] for c in self.parent.children)
+
         if self.gap:
             parent_width += (len_children - 1) * self.gap
-        self.children_rect.update(self.parent.get_content_left(),self.parent.get_content_top(), parent_width, parent_height)
+        self.children_rect.update(
+            self.parent.get_content_left(),
+            self.parent.get_content_top(),
+            parent_width,
+            parent_height,
+        )
         if self.center:
             self.children_rect.center = self.parent.get_content_center()
-        if self.shrink:
-            c = self.parent.get_constraint("width")
-            if not c or c.width != parent_width:
-                self.parent.add_constraints(ConstraintWidth(parent_width))
-            c = self.parent.get_constraint("height")
-            if not c or c.height != parent_height:
-                self.parent.add_constraints(ConstraintHeight(parent_height))
+        if self.fit_children:
+            self.parent.set_size(parent_width,parent_height)
+            
         current_x = self.children_rect.left
 
         for child in self.parent.children:
             child.set_position(current_x, self.parent.rect.y)
             current_x += child.rect.w + self.gap
             for c in self.child_constraints:
-                if not child.has_constraint(c.name):
-                    child.add_constraints(c)
-                    
+                child.add_constraints(c)

batFramework/gui/root.py

@@ -3,63 +3,76 @@ from .interactiveWidget import InteractiveWidget
 from .widget import Widget
 import pygame
 
+
 class Root(InteractiveWidget):
     def __init__(self):
         super().__init__()
         self.surface = None
         self.set_root()
         self.rect.size = pygame.display.get_surface().get_size()
-        self.focused : InteractiveWidget = self
-        self.hovered : Widget|None = self
+        self.focused: InteractiveWidget |None= self
+        self.hovered: Widget | None = self
         self.set_debug_color("purple")
 
-    def to_string(self)->str:
-         return "ROOT"
+    def to_string(self) -> str:
+        return "ROOT"
 
-    def get_focused(self)->Widget|None:
+    def get_focused(self) -> Widget | None:
         return self.focused
 
-    def get_hovered(self)->Widget|None:
+    def get_hovered(self) -> Widget | None:
         return self.hovered
-         
-    def to_string_id(self)->str:
+
+    def reset(self)->None:
+        self.focus_on(None)
+        self.hovered = None
+
+    def to_string_id(self) -> str:
         return "ROOT"
 
-    def focus_on(self,widget:InteractiveWidget)->None:
-        if self.focused is not None: 
+    def focus_on(self, widget: InteractiveWidget|None) -> None:
+        if self.focused is not None:
             self.focused.on_lose_focus()
-        if widget is None :
+        if widget is None:
             self.focused = self
             return
-        self.focused= widget
+        self.focused = widget
         self.focused.on_get_focus()
 
-    def set_size(self,width:float,height:float,force:bool=False)->"Root":
-        if not force :  return self
-        self.rect.size = width,height
+    def set_size(self, width: float, height: float, force: bool = False) -> "Root":
+        if not force:
+            return self
+        self.rect.size = width, height
         self.build(apply_constraints=True)
         return self
-        
-    def build(self,apply_constraints:bool=False)->None:
-        if apply_constraints : self.apply_all_constraints()
-        for child in self.children : 
+
+    def build(self, apply_constraints: bool = False) -> None:
+        if apply_constraints:
+            self.apply_all_constraints()
+        for child in self.children:
             child.build()
-    
-    def do_handle_event(self,event):
+
+    def do_handle_event(self, event):
         if event.type == pygame.VIDEORESIZE:
-            self.set_size(event.w,event.h,force=True)
+            self.set_size(event.w, event.h, force=True)
             return True
         return False
 
-    def update(self,dt:float)->None:
+    def get_root(self) -> "Root" :
+        return self
+
+
+    def update(self, dt: float) -> None:
         super().update(dt)
         old = self.hovered
-        self.hovered = self.top_at(*pygame.mouse.get_pos()) if self.top_at(*pygame.mouse.get_pos()) else None
-        if old == self.hovered:return
-        if isinstance(self.hovered,bf.Button):
+        self.hovered = (
+            self.top_at(*pygame.mouse.get_pos())
+            if self.top_at(*pygame.mouse.get_pos())
+            else None
+        )
+        if old == self.hovered:
+            return
+        if isinstance(self.hovered, bf.Button):
             pygame.mouse.set_cursor(*pygame.cursors.tri_left)
         else:
-            pygame.mouse.set_cursor()
-
-        
-
+            pygame.mouse.set_cursor(pygame.cursors.arrow)