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

batFramework/gui/image.py

@@ -1,42 +1,23 @@
 import batFramework as bf
 from .widget import Widget
 import pygame
-
-
 class Image(Widget):
-    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 __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 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 set_image(
-        self, data: pygame.Surface | str, size: None | tuple[int, int] = None
-    ):
-        if isinstance(data, str):
-            tmp = bf.ResourceManager().get_image(data,self.convert_alpha)
-        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 and self.original_surface:
-            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,46 +1,40 @@
 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)
-
-        #TODO aspect ratio would be good right about here
+    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) -> 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:
+    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,73 +1,22 @@
 from .widget import Widget
-from typing import Self
 
 class InteractiveWidget(Widget):
-    def __init__(self, *args, **kwargs)->None:
+    def __init__(self,*args,**kwargs):
+        super().__init__(convert_alpha = True)
         self.focusable = True
-        self.is_focused: bool = False
-        self.is_hovered: bool = False
-        self.is_clicked_down:bool = False
-        super().__init__(convert_alpha=True)
+        self.is_focused : bool = False
 
-    def set_focusable(self,value:bool)->Self:
-        self.focusable = value
-        return self
+    def get_focus(self)->bool:
+        if self.parent is None or not self.focusable: return False
+        self.get_root().focus_on(self)
 
-    def get_focus(self) -> bool:
-        if self.focusable and (r:=self.get_root()) is not None:
-            r.focus_on(self)
-            return True
-        return False
-
-    def lose_focus(self) -> bool:
-        if self.is_focused  and (r:=self.get_root()) is not None:
-            r.focus_on(None)
-            return True
-        return False
-
-        
-    def on_get_focus(self) -> None:
+    def on_get_focus(self)->None:
         self.is_focused = True
-        self.do_on_get_focus()
 
-
-    def on_lose_focus(self) -> None:
+    def on_lose_focus(self)->None:
         self.is_focused = False
-        self.do_on_lose_focus()
-
-
-    def do_on_get_focus(self)->None:
-        pass
         
-    def do_on_lose_focus(self)->None:
-        pass
-
-
-    def on_click_down(self,button:int)->None:
-        self.do_on_click_down(button)
-
-    def on_click_up(self,button:int)->None:
-        self.do_on_click_up(button)
-
-    def do_on_click_down(self,button:int)->None:    
-        pass
-
-    def do_on_click_up(self,button:int)->None:
-        pass
-
-    def on_enter(self)->None:
-        self.is_hovered = True
-        self.do_on_enter()
-
-    def on_exit(self)->None:
-        self.is_hovered = False
-        self.do_on_exit()
-
-
-    def do_on_enter(self)->None:
-        pass
-
-    def do_on_exit(self)->None:
-        pass
-
-
+    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

@@ -4,22 +4,14 @@ from .shape import Shape
 from typing import Self
 
 class Label(Shape):
-    _text_cache = {}
-    def __init__(self, text: str) -> None:
+    def __init__(self,text:str) -> None:   
         self._text = ""
-
-        self._resized_flag: bool = False
-
         # Enable/Disable antialiasing
-        self._antialias: bool = True
-
-        self._text_size = bf.FontManager().DEFAULT_TEXT_SIZE
-
-        self.auto_wraplength: bool = False
-
-        self._alignment: bf.Alignment = bf.Alignment.CENTER
-
-        self._text_color: tuple[int, int, int] | str = "black"
+        self._antialias : bool = True
+        
+        self._text_size = bf.const.DEFAULT_TEXT_SIZE
+        
+        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
@@ -27,147 +19,92 @@ 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
-
-        self._do_caching : bool = False
-        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_color("white")
         self.set_autoresize(True)
         self.set_font(force=True)
         self.set_text(text)
 
-
-    @staticmethod
-    def clear_cache():
-        Label._text_cache = {}
-    
-    def enable_caching(self)->Self:
-        self._do_caching = True
-        return self
-
-    def disable_caching(self)->Self:
-        self._do_caching = False
-        return self
-
-    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_alignment(self, alignment: bf.Alignment) -> "Label":
-        self._alignment = alignment
-        self.build()
-        return self
-
-    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.FontManager().get_font(self._font_name, self._text_size)
+        self._font_object = bf.utils.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.FontManager().get_font(self._font_name, self._text_size)
+        self._font_object = bf.utils.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 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:
+    def _build_text(self)-> None:
         if self._font_object is None:
-            print(f"No font for '{self.to_string_id()}' :(")
+            print("No font :(")
             return
         # render(text, antialias, color, bgcolor=None, wraplength=0) -> Surface
-
-        params = {
-            "font_name":self._font_object.name,
-            "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
-            }
-        
-        key = tuple(params.values())
-        cached_value =  Label._text_cache.get(key,None)
-        if cached_value != None:
-            self._text_surface = cached_value
-        else:
-            params.pop("font_name")
-            self._text_surface = self._font_object.render(**params)
-            if self._do_caching:
-                Label._text_cache[key] = self._text_surface
-        self._text_rect = self._text_surface.get_frect(topleft = self.get_content_rect_rel().topleft)
-
-    def _build_layout(self) -> None:
-        if self._text_rect is None : return
+        self._text_surface = self._font_object.render(
+            text        = self._text,
+            antialias   = self._antialias,
+            color       = self._text_color,
+            bgcolor     = self._color,
+            wraplength  = 0
+        )
+        self._text_rect = self._text_surface.get_frect()
+
+    def _build_layout(self)->None:
         if self.autoresize:
-            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)
+            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] 
+                )
                 return
-        if self._alignment == bf.Alignment.CENTER:
-            self._text_rect.center = self.get_content_rect_rel().center
-        elif self._alignment == bf.Alignment.LEFT:
-            self._text_rect.topleft = self.get_content_rect_rel().topleft
-        elif self._alignment == bf.Alignment.RIGHT:
-            self._text_rect.topright = self.get_content_rect_rel().topright
-        if self._resized_flag:
-            self._resized_flag = False
-            if self.parent:
-                # print("Children modified call")
-                self.parent.children_modified()
-
-        self.surface.fblits([(self._text_surface, self._text_rect)])
-
-    def build(self) -> None:
+        self._text_rect.center = self.get_content_rect_rel().center
+        self.surface.blit(self._text_surface,self._text_rect)
+                
+    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

@@ -2,95 +2,80 @@ import batFramework as bf
 from .widget import Widget
 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] = []
-        self.children_rect = pygame.FRect(0, 0, 0, 0)
-
-    def set_child_constraints(self, *constraints) -> Self:
-        self.child_constraints = list(constraints)
+        self.child_constraints : list[Constraint] = []
+        
+    def set_child_constraints(self,*constraints)->Self:
+        self.child_constraints = 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, fit_children: bool = True, center: bool = True):
+    def __init__(self,gap:int=0,shrink:bool=False):
         super().__init__()
         self.gap = gap
-        self.fit_children: bool = fit_children
-        self.center = center
-
-    def arrange(self) -> None:
-        if not self.parent or not self.parent.children:
-            return
-        len_children = len(self.parent.children)
-        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
+        self.shrink :bool = shrink
+        
+    def arrange(self)->None:
+        if not self.parent or not self.parent.children : return 
+        if self.shrink:
+            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
+            # print(self.parent.to_string(),len_children,parent_height)
+            c = self.parent.get_constraint("height")
+            if not c or c.height != parent_height : 
+                self.parent.add_constraint(ConstraintHeight(parent_height))
+            c = self.parent.get_constraint("width")
+            if not c or c.width != parent_width : 
+                self.parent.add_constraint(ConstraintWidth(parent_width))
+        current_y = self.parent.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:
-                child.add_constraints(c)
-
-
+                if not child.has_constraint(c.name):
+                    child.add_constraint(c)
+            
 class Row(Layout):
-    def __init__(self, gap: int = 0, fit_children: bool = True, center: bool = True):
+    def __init__(self, gap: int = 0, shrink: bool = False):
         super().__init__()
         self.gap = gap
-        self.fit_children: bool = fit_children
-        self.center = center
+        self.shrink = shrink
 
     def arrange(self) -> None:
-        if not self.parent or not self.parent.children:
+        if not self.parent:
             return
-
-        len_children = len(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,
-        )
-        if self.center:
-            self.children_rect.center = self.parent.get_content_center()
-        if self.fit_children:
-            self.parent.set_size(parent_width,parent_height)
-            
-        current_x = self.children_rect.left
-
+        if self.shrink and self.parent.children:
+            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)
+            if self.gap:
+                parent_width += (len_children - 1) * self.gap
+
+            c = self.parent.get_constraint("width")
+            if not c or c.width != parent_width:
+                self.parent.add_constraint(ConstraintWidth(parent_width))
+            c = self.parent.get_constraint("height")
+            if not c or c.height != parent_height:
+                self.parent.add_constraint(ConstraintHeight(parent_height))
+
+        current_x = self.parent.rect.left
         for child in self.parent.children:
-            child.set_position(current_x, self.parent.rect.y)
+            child.set_position(current_x,self.parent.rect.y)
             current_x += child.rect.w + self.gap
             for c in self.child_constraints:
-                child.add_constraints(c)
+                if not child.has_constraint(c.name):
+                    child.add_constraint(c)