batframework 1.0.8a1__py3-none-any.whl → 1.0.8a3__py3-none-any.whl

batFramework/gui/slider.py

@@ -6,7 +6,11 @@ from .meter import Meter
 from .shape import Shape
 from .interactiveWidget import InteractiveWidget
 
+
 class SliderHandle(Indicator, DraggableWidget):
+    def __init__(self):
+        super().__init__()
+        self.set_color(bf.color.CLOUD_SHADE)
 
     def __str__(self) -> str:
         return "SliderHandle"
@@ -20,9 +24,11 @@ class SliderHandle(Indicator, DraggableWidget):
         self.is_hovered = False
         self.do_on_exit()
 
-    def do_on_drag(self,drag_start:tuple[float,float],drag_end: tuple[float,float]) -> None:
-        super().do_on_drag(drag_start,drag_end)
-        m : Meter = self.parent.meter
+    def do_on_drag(
+        self, drag_start: tuple[float, float], drag_end: tuple[float, float]
+    ) -> None:
+        super().do_on_drag(drag_start, drag_end)
+        m: Meter = self.parent.meter
         r = m.get_padded_rect()
         position = self.rect.centerx
         self.rect.clamp_ip(r)
@@ -35,13 +41,13 @@ class SliderHandle(Indicator, DraggableWidget):
         return Widget.top_at(self, x, y)
 
 
-class SliderMeter(Meter,InteractiveWidget):
+class SliderMeter(Meter, InteractiveWidget):
 
     def __str__(self) -> str:
         return "SliderMeter"
 
-    def on_click_down(self,button:int)->None:
-        if button == 1 : 
+    def on_click_down(self, button: int) -> None:
+        if button == 1:
             self.parent.get_focus()
             r = self.get_root()
             if r:
@@ -50,20 +56,26 @@ class SliderMeter(Meter,InteractiveWidget):
 
         self.do_on_click_down(button)
 
+
 class Slider(Button):
     def __init__(self, text: str, default_value: float = 1.0) -> None:
         super().__init__(text, None)
         self.gap: float | int = 0
-        self.spacing :bf.spacing = bf.spacing.MANUAL 
+        self.spacing: bf.spacing = bf.spacing.MANUAL
         self.modified_callback = None
         self.meter: SliderMeter = SliderMeter()
-        self.handle =  SliderHandle().set_color(bf.color.CLOUD)
-        self.add(self.meter,self.handle)
+        self.handle = SliderHandle()
+        self.add(self.meter, self.handle)
         self.meter.set_debug_color(bf.color.RED)
-        self.set_value(default_value,True)
+        self.set_value(default_value, True)
         # print(self.handle.rect)
         # self.handle.set_visible(False)
-        
+
+    def set_visible(self, value: bool) -> Self:
+        self.handle.set_visible(value)
+        self.meter.set_visible(value)
+        return super().set_visible(value)
+
     def __str__(self) -> str:
         return "Slider"
 
@@ -81,14 +93,17 @@ class Slider(Button):
                 "antialias": False,
                 "color": "white",
                 "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
+                "wraplength": (
+                    int(self.get_padded_width()) if self.auto_wraplength else 0
+                ),
             }
             self.text_rect.size = self._render_font(params).get_size()
-        w,h = self.text_rect.size
-        return self.inflate_rect_by_padding((0, 0,w + gap + self.meter.rect.w,h)).size
+        w, h = self.text_rect.size
+        return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.rect.w, h)).size
 
-    def set_spacing(self,spacing:bf.spacing)->Self:
-        if spacing == self.spacing : return self
+    def set_spacing(self, spacing: bf.spacing) -> Self:
+        if spacing == self.spacing:
+            return self
         self.spacing = spacing
         self.dirty_shape = True
         return self
@@ -106,14 +121,14 @@ class Slider(Button):
         return self
 
     def set_value(self, value, no_callback: bool = False) -> Self:
-        if self.meter.value != value :
+        if self.meter.value != value:
             self.meter.set_value(value)
             self.dirty_shape = True
         if self.modified_callback and (not no_callback):
             self.modified_callback(self.meter.value)
         return self
-    
-    def get_value(self)->float:
+
+    def get_value(self) -> float:
         return self.meter.get_value()
 
     def do_on_key_down(self, key):
@@ -123,9 +138,10 @@ class Slider(Button):
         elif key == pygame.K_LEFT:
             self.set_value(self.meter.get_value() - self.meter.step)
             bf.AudioManager().play_sound(self.click_down_sound)
-            
+
     def do_on_click_down(self, button) -> None:
-        if button == 1 : self.get_focus()
+        if button == 1:
+            self.get_focus()
 
     def value_to_position(self, value: float) -> float:
         """
@@ -137,22 +153,28 @@ class Slider(Button):
         position_ratio = (value - self.meter.min_value) / value_range
         # print(self.handle.rect)
         # print(rect.left + (self.handle.rect.w/2) + position_ratio * (rect.width - self.handle.rect.w),self.handle.rect.w,self.rect.right)
-        return rect.left + (self.handle.rect.w/2) + position_ratio * (rect.width - self.handle.rect.w)
+        return (
+            rect.left
+            + (self.handle.rect.w / 2)
+            + position_ratio * (rect.width - self.handle.rect.w)
+        )
 
     def position_to_value(self, position: float) -> float:
         """
         Converts a position on the meter to a value, considering the step size.
         """
-        handle_half = self.handle.rect.w/2
+        handle_half = self.handle.rect.w / 2
         rect = self.meter.get_padded_rect()
         position = max(rect.left + handle_half, min(position, rect.right - handle_half))
 
-        position_ratio = (position - rect.left - handle_half) / (rect.width - self.handle.rect.w)
+        position_ratio = (position - rect.left - handle_half) / (
+            rect.width - self.handle.rect.w
+        )
         value_range = self.meter.get_range()
         value = self.meter.min_value + position_ratio * value_range
         return round(value / self.meter.step) * self.meter.step
 
-    def _build_layout(self) -> None:        
+    def _build_layout(self) -> None:
 
         gap = self.gap if self.text else 0
 
@@ -169,52 +191,56 @@ class Slider(Button):
 
         meter_size = [self.text_rect.h * 10, self.font_object.point_size]
         if not self.autoresize_w:
-            meter_size[0] =  self.get_padded_width() - self.text_rect.w - gap
-
-        tmp_rect = pygame.FRect(0,0,self.text_rect.w + gap + meter_size[0],self.text_rect.h)
-
+            meter_size[0] = self.get_padded_width() - self.text_rect.w - gap
 
+        tmp_rect = pygame.FRect(
+            0, 0, self.text_rect.w + gap + meter_size[0], self.text_rect.h
+        )
 
-        if self.autoresize_h or self.autoresize_w: 
+        if self.autoresize_h or self.autoresize_w:
             target_rect = self.inflate_rect_by_padding(tmp_rect)
-            if not self.autoresize_w : target_rect.w = self.rect.w
-            if not self.autoresize_h : target_rect.h = self.rect.h
+            if not self.autoresize_w:
+                target_rect.w = self.rect.w
+            if not self.autoresize_h:
+                target_rect.h = self.rect.h
             if self.rect.size != target_rect.size:
                 self.set_size(target_rect.size)
                 self.build()
                 return
 
         # ------------------------------------ size is ok
-        padded = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
+        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
 
         self.meter.set_size_if_autoresize(meter_size)
-        handle_size = 2*[self.meter.get_padded_height()]
-        
+        handle_size = 2 * [self.meter.get_padded_height()]
+
         self.handle.set_size_if_autoresize(handle_size)
 
-        self.align_text(tmp_rect,padded,self.alignment)
+        self.align_text(tmp_rect, padded, self.alignment)
         self.text_rect.midleft = tmp_rect.midleft
 
-        if self.text : 
+        if self.text:
             match self.spacing:
                 case bf.spacing.MAX:
                     gap = padded.w - self.text_rect.w - self.meter.rect.w
                 case bf.spacing.MIN:
                     gap = 0
-                case bf.spacing.HALF:
-                    gap = (padded.w)/2 - self.text_rect.w
 
-        # place meter 
+        # place meter
 
-        self.meter.set_position(*self.text_rect.move(self.rect.x + gap,self.rect.y + (self.text_rect.h /2) - meter_size[1]/2).topright)
+        self.meter.set_position(
+            *self.text_rect.move(
+                self.rect.x + gap,
+                self.rect.y + (self.text_rect.h / 2) - meter_size[1] / 2,
+            ).topright
+        )
         # place handle
 
         # print(self.meter.rect.top - self.rect.top)
         # print(self.meter.rect.h)
-        
+
         x = self.value_to_position(self.meter.value)
         r = self.meter.get_padded_rect()
-        self.handle.set_center(x,r.centery)
+        self.handle.set_center(x, r.centery)
 
         # self.handle.set_center(x,self.rect.top)
-

batFramework/gui/style.py

@@ -0,0 +1,10 @@
+from .widget import Widget
+
+
+class Style:
+
+    def __init__(self):
+        pass
+
+    def apply(self, widget: Widget):
+        pass

batFramework/gui/styleManager.py

@@ -0,0 +1,48 @@
+from ..utils import Singleton
+from .widget import Widget
+
+
+class Style:
+    def __init__(self):
+        pass
+
+    def apply(self, widget: Widget):
+        pass
+
+
+class StyleManager(metaclass=Singleton):
+    def __init__(self):
+        self.styles: list[Style] = []
+        self.widgets: set[Widget] = set()
+        self.lookup: dict[Widget, bool] = {}
+
+    def register_widget(self, widget: Widget):
+        if widget in self.widgets:
+            return
+        self.widgets.add(widget)
+        self.lookup[widget] = False
+        self.update()
+
+    def refresh_widget(self, widget: Widget):
+        if widget in self.widgets:
+            self.lookup[widget] = True
+            self.update()
+
+    def remove_widget(self, widget: Widget):
+        if widget not in self.widgets:
+            return
+        self.widgets.remove(widget)
+        self.lookup.pop(widget)
+
+    def add(self, style: Style):
+        self.styles.append(style)
+        self.lookup = {key: False for key in self.lookup}
+        self.update()
+
+    def update(self):
+        for widget in self.widgets:
+            if self.lookup[widget]:
+                continue
+            for style in self.styles:
+                style.apply(widget)
+            self.lookup[widget] = True

batFramework/gui/textInput.py

@@ -1,5 +1,5 @@
 import batFramework as bf
-from typing import Self,Callable
+from typing import Self, Callable
 from .label import Label
 from .interactiveWidget import InteractiveWidget
 import pygame
@@ -12,20 +12,21 @@ class TextInput(Label, InteractiveWidget):
         self.cursor_timer = bf.Timer(0.3, self._cursor_toggle, loop=True).start()
         self.cursor_timer.pause()
         self.show_cursor: bool = False
-        self.on_modify :Callable[[str],str] = None 
+        self.on_modify: Callable[[str], str] = None
         self.set_focusable(True)
         self.set_outline_color("black")
         super().__init__("")
 
-    def set_modify_callback(self,callback : Callable[[str],str])->Self:
+    def set_modify_callback(self, callback: Callable[[str], str]) -> Self:
         self.on_modify = callback
         return self
 
-    def to_string_id(self) -> str:
+    def __str__(self) -> str:
         return f"TextInput({self.text})"
 
-    def _cursor_toggle(self,value:bool = None):
-        if value is None : value = not self.show_cursor
+    def _cursor_toggle(self, value: bool = None):
+        if value is None:
+            value = not self.show_cursor
         self.show_cursor = value
         self.dirty_surface = True
 
@@ -44,6 +45,7 @@ class TextInput(Label, InteractiveWidget):
         self.old_key_repeat = pygame.key.get_repeat()
         self.cursor_timer.resume()
         self._cursor_toggle(True)
+        self.set_cursor_position(len(self.get_text()))
         pygame.key.set_repeat(200, 50)
 
     def do_on_lose_focus(self):
@@ -75,10 +77,10 @@ class TextInput(Label, InteractiveWidget):
         elif event.type == pygame.KEYDOWN:
             if event.key == pygame.K_ESCAPE:
                 self.lose_focus()
-        
+
             elif event.key == pygame.K_BACKSPACE:
                 if cursor_position > 0:
-                    self.set_text(text[:cursor_position - 1] + text[cursor_position:])
+                    self.set_text(text[: cursor_position - 1] + text[cursor_position:])
                     self.set_cursor_position(cursor_position - 1)
 
             elif event.key == pygame.K_RIGHT:
@@ -89,13 +91,14 @@ class TextInput(Label, InteractiveWidget):
 
             else:
                 return
-        else : 
+        else:
             return
 
         event.consumed = True
-        
+
     def set_text(self, text: str) -> Self:
-        if self.on_modify : text = self.on_modify(text)
+        if self.on_modify:
+            text = self.on_modify(text)
         return super().set_text(text)
 
     def _paint_cursor(self) -> None:
@@ -104,8 +107,8 @@ class TextInput(Label, InteractiveWidget):
         partial_text_size = self.font_object.size(
             self.get_text()[: self.cursor_position]
         )
-        
-        cursor_rect = pygame.Rect(0, 0,1, self.font_object.point_size )
+
+        cursor_rect = pygame.Rect(0, 0, 1, self.font_object.point_size)
         if self.cursor_position != 0:  # align left properly
             cursor_rect.midleft = self.text_rect.move(partial_text_size[0], 0).midleft
         else:
@@ -117,18 +120,18 @@ class TextInput(Label, InteractiveWidget):
         super().paint()
         self._paint_cursor()
 
-
-    def align_text(self,text_rect:pygame.FRect,area:pygame.FRect,alignment: bf.alignment):
-        if alignment == bf.alignment.LEFT : alignment = bf.alignment.MIDLEFT
-        elif alignment == bf.alignment.MIDRIGHT : alignment = bf.alignment.MIDRIGHT
+    def align_text(
+        self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
+    ):
+        if alignment == bf.alignment.LEFT:
+            alignment = bf.alignment.MIDLEFT
+        elif alignment == bf.alignment.MIDRIGHT:
+            alignment = bf.alignment.MIDRIGHT
 
         pos = area.__getattribute__(alignment.value)
-        text_rect.__setattr__(alignment.value,pos)
-        w = self.font_object.size(
-            self.get_text()[: self.cursor_position]
-        )[0]
+        text_rect.__setattr__(alignment.value, pos)
+        w = self.font_object.size(self.get_text()[: self.cursor_position])[0]
         if self.text_rect.x + w > area.right:
             self.text_rect.right = area.right
         elif self.text_rect.x + w < area.left:
             self.text_rect.left = area.left - w
-        

batFramework/gui/toggle.py

@@ -6,15 +6,19 @@ import pygame
 
 
 class Toggle(Button):
-    def __init__(self, text: str, callback=None,default_value: bool = False) -> None:
+    def __init__(self, text: str, callback=None, default_value: bool = False) -> None:
         self.value: bool = default_value
         self.indicator: ToggleIndicator = ToggleIndicator(default_value)
         self.gap: float | int = 0
-        self.spacing :bf.spacing = bf.spacing.MANUAL 
+        self.spacing: bf.spacing = bf.spacing.MANUAL
         super().__init__(text, callback)
         self.add(self.indicator)
         # self.set_gap(int(max(4, self.get_padded_width() / 3)))
 
+    def set_visible(self, value: bool) -> Self:
+        self.indicator.set_visible(value)
+        return super().set_visible(value)
+
     def set_value(self, value: bool, do_callback=False) -> Self:
         self.value = value
         self.indicator.set_value(value)
@@ -23,18 +27,20 @@ class Toggle(Button):
             self.callback(self.value)
         return self
 
-    def set_spacing(self,spacing:bf.spacing)->Self:
-        if spacing == self.spacing : return self
+    def set_spacing(self, spacing: bf.spacing) -> Self:
+        if spacing == self.spacing:
+            return self
         self.spacing = spacing
         self.dirty_shape = True
         return self
-    
+
     def click(self) -> None:
         self.set_value(not self.value, True)
 
     def set_gap(self, value: int | float) -> Self:
         value = max(0, value)
-        if value == self.gap : return self
+        if value == self.gap:
+            return self
         self.gap = value
         self.dirty_shape = True
         return self
@@ -53,18 +59,25 @@ class Toggle(Button):
                 "antialias": False,
                 "color": "white",
                 "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
+                "wraplength": (
+                    int(self.get_padded_width()) if self.auto_wraplength else 0
+                ),
             }
             self.text_rect.size = self._render_font(params).get_size()
-        w,h = self.text_rect.size
-        size = max(self.indicator.rect.w,w + self.font_object.point_size + (self.gap if self.text else 0)), max(h,self.font_object.point_size,self.indicator.rect.h)
-        return self.inflate_rect_by_padding((0,0,*size)).size
+        w, h = self.text_rect.size
+        size = (
+            max(
+                self.indicator.rect.w,
+                w + self.font_object.point_size + (self.gap if self.text else 0),
+            ),
+            self.text_rect.h,
+        )
+        return self.inflate_rect_by_padding((0, 0, *size)).size
 
-        
     def _build_layout(self) -> None:
 
-        gap = self.gap if self.text else 0 
-        
+        gap = self.gap if self.text else 0
+
         params = {
             "font_name": self.font_object.name,
             "text": self.text,
@@ -77,37 +90,37 @@ class Toggle(Button):
 
         indicator_height = self.font_object.point_size
 
-        self.indicator.set_size((indicator_height,indicator_height))
-
-        
-        tmp_rect = pygame.FRect(0,0,self.text_rect.w + gap + indicator_height , self.text_rect.h)
+        self.indicator.set_size((indicator_height, indicator_height))
 
+        tmp_rect = pygame.FRect(
+            0, 0, self.text_rect.w + gap + indicator_height, self.text_rect.h
+        )
 
-        if self.autoresize_h or self.autoresize_w: 
+        if self.autoresize_h or self.autoresize_w:
             target_rect = self.inflate_rect_by_padding(tmp_rect)
-            if not self.autoresize_w : target_rect.w = self.rect.w
-            if not self.autoresize_h : target_rect.h = self.rect.h
+            if not self.autoresize_w:
+                target_rect.w = self.rect.w
+            if not self.autoresize_h:
+                target_rect.h = self.rect.h
             if self.rect.size != target_rect.size:
                 self.set_size(target_rect.size)
                 self.build()
                 return
-            
-        padded = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
-        
-        self.align_text(tmp_rect,padded,self.alignment)
+
+        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
+
+        self.align_text(tmp_rect, padded, self.alignment)
         self.text_rect.midleft = tmp_rect.midleft
-        if self.text : 
+        if self.text:
             match self.spacing:
                 case bf.spacing.MAX:
                     gap = padded.w - self.text_rect.w - self.indicator.rect.w
                 case bf.spacing.MIN:
                     gap = 0
-                case bf.spacing.HALF:
-                    gap = (padded.w)/2 - self.text_rect.w
 
         self.indicator.set_position(
             *self.text_rect.move(
-                self.rect.x+gap,
-                self.rect.y + (self.text_rect.h /2) - self.indicator.rect.h/2
+                self.rect.x + gap,
+                self.rect.y + (self.text_rect.h / 2) - self.indicator.rect.h / 2,
             ).topright
         )