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

batFramework/gui/textInput.py

@@ -1,88 +1,134 @@
 import batFramework as bf
-from typing import Self
+from typing import Self,Callable
 from .label import Label
 from .interactiveWidget import InteractiveWidget
 import pygame
 
-class TextInput(Label,InteractiveWidget):
-    def __init__(self)->None:
+
+class TextInput(Label, InteractiveWidget):
+    def __init__(self) -> None:
         self.cursor_position = 0
-        self.cursor_color = "gray20"
-        super().__init__("A")
-        self.set_text("")
+        self.old_key_repeat: tuple = (0, 0)
+        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.set_focusable(True)
         self.set_outline_color("black")
-        self.old_key_repeat :tuple= (0,0)
-        self._cursor_timer = bf.Timer(0.3,self._cursor_toggle,loop=True).start()
-        self._cursor_timer.pause()
-        self._show_cursor :bool = True
+        super().__init__("")
+
+    def set_modify_callback(self,callback : Callable[[str],str])->Self:
+        self.on_modify = callback
+        return self
 
     def to_string_id(self) -> str:
-        return f"TextInput({self._text})"
+        return f"TextInput({self.text})"
 
-    def _cursor_toggle(self):
-        self._show_cursor = not self._show_cursor
-        self.build()
+    def _cursor_toggle(self,value:bool = None):
+        if value is None : value = not self.show_cursor
+        self.show_cursor = value
+        self.dirty_surface = True
 
-    def set_cursor_color(self,color)->Self:
-        self.cursor_color = color
-        return self
-        
-    def do_on_click_down(self,button):
-        if button != 1:return
+    def do_on_click_down(self, button):
+        if button != 1:
+            return
         self.get_focus()
+
     def do_on_enter(self):
         pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_IBEAM)
 
     def do_on_exit(self):
-        pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_ARROW)
+        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
 
     def do_on_get_focus(self):
-        self.set_outline_width(2)
         self.old_key_repeat = pygame.key.get_repeat()
-        self._cursor_timer.resume()
-        pygame.key.set_repeat(200,100)
+        self.cursor_timer.resume()
+        self._cursor_toggle(True)
+        pygame.key.set_repeat(200, 50)
+
     def do_on_lose_focus(self):
-        self.set_outline_width(0)
-        self._cursor_timer.pause()
+        self.cursor_timer.pause()
+        self._cursor_toggle(False)
         pygame.key.set_repeat(*self.old_key_repeat)
 
-    def set_cursor_position(self,position:int)->Self:
-        if position < 0 : position = 0
-        elif position > len(self.get_text()): position = len(self.get_text())
+    def set_cursor_position(self, position: int) -> Self:
+        if position < 0:
+            position = 0
+        elif position > len(self.get_text()):
+            position = len(self.get_text())
         self.cursor_position = position
-        self.build()
+        self.show_cursor = True
+        self.dirty_surface = True
+        if self.text_rect.w > self.get_padded_width():
+            self.dirty_shape = True
         return self
 
-    def do_handle_event(self,event)->bool:
+    def do_handle_event(self, event):
+        if not self.is_focused:
+            return
         text = self.get_text()
-        if not self.is_focused : return False
+        cursor_position = self.cursor_position
+
         if event.type == pygame.TEXTINPUT:
-            self.set_text(text[:self.cursor_position]+event.text+text[self.cursor_position:])
-            self.set_cursor_position(self.cursor_position+1)
-            return True
-        if event.type == pygame.KEYDOWN and event.key == pygame.K_BACKSPACE:
-            if self.cursor_position != 0 : 
-                self.set_text(text[:self.cursor_position-1]+text[self.cursor_position:])
-                self.set_cursor_position(self.cursor_position-1)
-            return True
-
-        if event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
-            self.set_cursor_position(self.cursor_position+1)
-            return True
-        if event.type == pygame.KEYDOWN and event.key == pygame.K_LEFT:
-            self.set_cursor_position(self.cursor_position-1)
-            return True
-        return False
-
-    def _build_cursor(self)->None:
-        if not self._font_object : return
-        if not self._show_cursor : return
-        partial_text_size = self._font_object.size(self.get_text()[:self.cursor_position])
-        cursor_rect = pygame.Rect(0,0,2,partial_text_size[1]+2)
-        cursor_rect.midleft = self._text_rect.move(partial_text_size[0],0).midleft
-        pygame.draw.rect(self.surface, self.cursor_color, cursor_rect)
-
-    def build(self)->None:
-        super().build()
-        if self.is_focused : self._build_cursor()
+            self.set_text(text[:cursor_position] + event.text + text[cursor_position:])
+            self.set_cursor_position(cursor_position + 1)
+        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_cursor_position(cursor_position - 1)
+
+            elif event.key == pygame.K_RIGHT:
+                self.set_cursor_position(cursor_position + 1)
+
+            elif event.key == pygame.K_LEFT:
+                self.set_cursor_position(cursor_position - 1)
+
+            else:
+                return
+        else : 
+            return
+
+        event.consumed = True
+        
+    def set_text(self, text: str) -> Self:
+        if self.on_modify : text = self.on_modify(text)
+        return super().set_text(text)
+
+    def _paint_cursor(self) -> None:
+        if not self.font_object or not self.show_cursor:
+            return
+        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 )
+        if self.cursor_position != 0:  # align left properly
+            cursor_rect.midleft = self.text_rect.move(partial_text_size[0], 0).midleft
+        else:
+            cursor_rect.midright = self.text_rect.midleft
+
+        pygame.draw.rect(self.surface, self.text_color, cursor_rect)
+
+    def paint(self) -> None:
+        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
+
+        pos = area.__getattribute__(alignment.value)
+        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

@@ -1,70 +1,113 @@
 from .button import Button
 from .indicator import Indicator, ToggleIndicator
-import pygame
 import batFramework as bf
 from typing import Self
-
+import pygame
 
 
 class Toggle(Button):
-    def __init__(self, text: str, default_value: bool = False,callback=None) -> None:
+    def __init__(self, text: str, callback=None,default_value: bool = False) -> None:
         self.value: bool = default_value
-        self.on_toggle = None
-        self.indicator: Indicator = ToggleIndicator(default_value)
+        self.indicator: ToggleIndicator = 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)
+        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_value(self,value:bool,do_callback=False)->Self:
+    def set_value(self, value: bool, do_callback=False) -> Self:
         self.value = value
-        self.build()
+        self.indicator.set_value(value)
+        self.dirty_surface = True
+        if do_callback and self.callback:
+            self.callback(self.value)
+        return self
 
-        if do_callback and self.on_toggle is not None: self.on_toggle(self.value)
+    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:
-        if value < 0:
-            return self
+        value = max(0, value)
+        if value == self.gap : return self
         self.gap = value
-        self.build()
-        if self.parent:
-            self.parent.children_modified()
+        self.dirty_shape = True
         return self
 
-    def to_string_id(self) -> str:
+    def __str__(self) -> str:
         return f"Toggle({self.value})"
 
     def toggle(self) -> None:
-        self.set_value(not self.value,do_callback = True)
+        self.set_value(not self.value, do_callback=True)
 
+    def get_min_required_size(self) -> tuple[float, float]:
+        if not self.text_rect:
+            params = {
+                "font_name": self.font_object.name,
+                "text": self.text,
+                "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,
+            }
+            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
 
-    def set_toggle_callback(self, callback) -> Self:
-        self.on_toggle = callback
-        return self
-
+        
     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),
-        )
 
-        required_rect = self.inflate_rect_by_padding(size)
+        gap = self.gap if self.text else 0 
+        
+        params = {
+            "font_name": self.font_object.name,
+            "text": self.text,
+            "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,
+        }
+        self.text_rect.size = self._render_font(params).get_size()
+
+        indicator_height = self.font_object.point_size
 
-        if self.autoresize and (self.rect.size != required_rect.size):
-            self.set_size(*required_rect.size)
-            return
+        self.indicator.set_size((indicator_height,indicator_height))
 
-        required_rect = self.get_content_rect()
-        required_rect_rel = self.get_content_rect_rel()
+        
+        tmp_rect = pygame.FRect(0,0,self.text_rect.w + gap + indicator_height , self.text_rect.h)
 
-        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
-        self.indicator.set_position(*r.topleft)
 
-        self.surface.blit(self._text_surface, self._text_rect)
+        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 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)
+        self.text_rect.midleft = tmp_rect.midleft
+        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
+            ).topright
+        )