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

batFramework/gui/root.py

@@ -3,99 +3,58 @@ from .interactiveWidget import InteractiveWidget
 from .widget import Widget
 import pygame
 
-
 class Root(InteractiveWidget):
-    def __init__(self,camera)->None:
+    def __init__(self):
         super().__init__()
-        self.drawing_camera = camera
         self.surface = None
         self.set_root()
         self.rect.size = pygame.display.get_surface().get_size()
-        self.focused: InteractiveWidget |None= self
-        self.hovered: Widget | None = self
+        self.focused : InteractiveWidget = 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 to_string_id(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:
+        return "ROOT"
 
-    def clear_focused(self)->None:
-        self.focus_on(None)
-
-    def clear_hovered(self)->None:
-        if isinstance(self.hovered,InteractiveWidget):   self.hovered.on_exit()
-        self.hovered = None
-
-    def focus_on(self, widget: InteractiveWidget|None) -> None:
-        if self.focused is not None:
+    def focus_on(self,widget:InteractiveWidget)->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
-        if event.type == pygame.MOUSEBUTTONDOWN:
-            if self.hovered and isinstance(self.hovered,InteractiveWidget) :
-                self.hovered.on_click_down(event.button)
-        if event.type == pygame.MOUSEBUTTONUP:
-            if self.hovered and isinstance(self.hovered,InteractiveWidget) :
-                self.hovered.on_click_up(event.button)            
-
         return False
 
-    def get_root(self) -> "Root" :
-        return self
-
-    def do_on_click_down(self,button:int)->None:
-        if button == 1 : self.clear_focused()
-
-    def top_at(self, x: float|int, y: float|int) -> "None|Widget":
-        if self.children:
-            for child in reversed(self.children):
-                r = child.top_at(x, y)
-                if r is not None:
-                    return r
-        return self if self.rect.collidepoint(x,y) else None
-
-    def update(self, dt: float) -> None:
+    def update(self,dt:float)->None:
         super().update(dt)
-        old = self.hovered
-        transposed = self.drawing_camera.convert_screen_to_world(*pygame.mouse.get_pos())
-        self.hovered = (
-            self.top_at(*transposed)
-            if self.top_at(*transposed)
-            else None
-        )
-        if old == self.hovered:
-            return
-        if old and isinstance(old,InteractiveWidget):    
-            old.on_exit()
-        if self.hovered and isinstance(self.hovered,InteractiveWidget) :
-            self.hovered.on_enter()
+        self.hovered = self.top_at(*pygame.mouse.get_pos()) if self.top_at(*pygame.mouse.get_pos()) else None
+        
 
+
+        

batFramework/gui/shape.py

@@ -4,76 +4,83 @@ import pygame
 
 
 class Shape(Widget):
-    def __init__(self, width: float, height: float):
-        self._color = (0, 0, 0, 0)
-        self._border_radius: list[int] = [0]
-        self._outline: int = 0
-        self._outline_color: tuple[int, int, int] | str = (0, 0, 0, 0)
-        super().__init__(convert_alpha=True)
-        self.set_size(width, height)
+    def __init__(self,width:float,height:float):
+        self._color = (0,0,0,0)
+        self._border_radius:list[int] = [0] 
+        self._outline : int = 0 
+        self._outline_color : tuple[int,int,int] | str = (0,0,0,0) 
+        super().__init__(convert_alpha = True)
+        self.set_size(width,height)
 
-    def to_string_id(self) -> str:
+
+    def to_string_id(self)->str:
         return "Shape"
 
-    def set_color(self, color: tuple[int, int, int] | str) -> "Frame":
+    def set_color(self,color:tuple[int,int,int]|str) -> "Frame":
         self._color = color
         self.build()
         return self
 
-    def set_outline_color(self, color: tuple[int, int, int] | str) -> "Frame":
+    def set_outline_color(self,color:tuple[int,int,int]|str) -> "Frame":
         self._outline_color = color
         self.build()
         return self
 
-    def set_border_radius(self, value: int | list[int]) -> "Frame":
-        if isinstance(value, int):
+    def set_border_radius(self,value:int|list[int]) -> "Frame":
+        if isinstance(value,int):
             self._border_radius = [value]
         else:
             self._border_radius = value
         self.build()
         return self
-
-    def set_outline_width(self, value: int) -> "Frame":
+        
+    def set_outline_width(self,value:int) -> "Frame":
         self._outline = value
         self.build()
         return self
-
-    def build(self) -> None:
+        
+    def build(self)->None:
         if self.surface.get_size() != self.get_size_int():
             self.surface = pygame.Surface(self.get_size_int())
-            if self.convert_alpha:
+            if self.convert_alpha :
                 self.surface = self.surface.convert_alpha()
-                self.surface.fill((0, 0, 0, 0))
-            if self.parent:
+                self.surface.fill((0,0,0,0))
+            if self.parent :
                 self.parent.children_modified()
         if self._border_radius == [0]:
-            self._build_shape()
-            if self._outline:
-                self._build_outline()
+            self._build_shape()    
+            if self._outline : self._build_outline()
         else:
             self._build_rounded_shape()
-            if self._outline:
-                self._build_rounded_outline()
+            if self._outline : self._build_rounded_outline()
+
 
-    def _build_shape(self) -> None:
+    def _build_shape(self)->None:
         self.surface.fill(self._color)
 
-    def _build_rounded_shape(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
+    def _build_rounded_shape(self)->None:
+        self.surface.fill((0,0,0,0))
         pygame.draw.rect(
-            self.surface, self._color, (0, 0, *self.rect.size), 0, *self._border_radius
+            self.surface,
+            self._color,
+            (0,0,*self.rect.size),
+            0,
+            *self._border_radius
         )
 
-    def _build_outline(self) -> None:
+    def _build_outline(self)->None:
         pygame.draw.rect(
-            self.surface, self._outline_color, (0, 0, *self.rect.size), self._outline
+            self.surface,
+            self._outline_color,
+            (0,0,*self.rect.size),
+            self._outline
         )
-
-    def _build_rounded_outline(self) -> None:
+    
+    def _build_rounded_outline(self)->None:
         pygame.draw.rect(
             self.surface,
             self._outline_color,
-            (0, 0, *self.rect.size),
+            (0,0,*self.rect.size),
             self._outline,
-            *self._border_radius,
+            *self._border_radius
         )

batFramework/gui/toggle.py

@@ -1,61 +1,52 @@
 from .button import Button
-from .indicator import Indicator, ToggleIndicator
+from .indicator import Indicator,ToggleIndicator
 import pygame
 import batFramework as bf
 from typing import Self
 
-
-
 class Toggle(Button):
-    def __init__(self, text: str, default_value: bool = False,callback=None) -> None:
-        self.value: bool = default_value
+    def __init__(self,text:str,default_value : bool = False)->None:
+        self.value :bool= default_value
         self.on_toggle = None
-        self.indicator: Indicator = ToggleIndicator(default_value)
-        self.gap: float | int = 0
-        super().__init__(text, self.toggle)
+        self.indicator : Indicator=ToggleIndicator(default_value)
+        self.gap :float|int = 0
+        super().__init__(text,self.toggle)
         self.add_child(self.indicator)
-        self.set_gap(int(max(4, self.get_content_width() / 3)))
-        self.set_toggle_callback(callback)
-
-    def set_value(self,value:bool,do_callback=False)->Self:
-        self.value = value
-        self.build()
+        self.set_gap(int(max(4,self.get_content_width()/3)))
+        # self.set_gap()
+        # self.set_gap(20)
 
-        if do_callback and self.on_toggle is not None: self.on_toggle(self.value)
-        return self
-    def set_gap(self, value: int | float) -> Self:
-        if value < 0:
-            return self
+    def set_gap(self,value:int|float)->Self:
+        if value < 0 : return self
         self.gap = value
         self.build()
-        if self.parent:
-            self.parent.children_modified()
+        if self.parent : self.parent.children_modified()
         return self
-
-    def to_string_id(self) -> str:
+    def to_string_id(self)->str:
         return f"Toggle({self.value})"
+        
+    def toggle(self)->None:
+        self.value = not self.value
+        self.build()
+        if self.on_toggle : self.on_toggle(self.value)
 
-    def toggle(self) -> None:
-        self.set_value(not self.value,do_callback = True)
-
-
-    def set_toggle_callback(self, callback) -> Self:
+    def set_toggle_callback(self,callback)->Self:
         self.on_toggle = callback
         return self
 
-    def _build_layout(self) -> None:
+    def _build_layout(self)->None:
         self.indicator.set_value(self.value)
-        self.indicator.set_size(self._text_rect.h,self._text_rect.h)
+        
         size = (
             0,
             0,
             self._text_rect.w + self.indicator.rect.w + self.gap,
-            max(self._text_rect.h, self.indicator.rect.h),
+            max(self._text_rect.h, self.indicator.rect.h)
         )
-
+        
         required_rect = self.inflate_rect_by_padding(size)
-
-        if self.autoresize and (self.rect.size != required_rect.size):
+        
+        if self.autoresize and (self.rect.size != required_rect.size) :
             self.set_size(*required_rect.size)
             return
 
@@ -64,7 +55,8 @@ class Toggle(Button):
 
         self._text_rect.midleft = required_rect_rel.midleft
         r = self.indicator.rect.copy()
-        r.midleft = required_rect.move(self._text_rect.w + self.gap, 0).midleft
+        r.midleft = required_rect.move(self._text_rect.w+self.gap,0).midleft
         self.indicator.set_position(*r.topleft)
-
-        self.surface.blit(self._text_surface, self._text_rect)
+        
+        self.surface.blit(self._text_surface,self._text_rect)
+