batframework 1.0.8a2__py3-none-any.whl → 1.0.8a4__py3-none-any.whl

batFramework/gui/textInput.py

@@ -0,0 +1,137 @@
+import batFramework as bf
+from typing import Self, Callable
+from .label import Label
+from .interactiveWidget import InteractiveWidget
+import pygame
+
+
+class TextInput(Label, InteractiveWidget):
+    def __init__(self) -> None:
+        self.cursor_position = 0
+        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")
+        super().__init__("")
+
+    def set_modify_callback(self, callback: Callable[[str], str]) -> Self:
+        self.on_modify = callback
+        return self
+
+    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
+        self.show_cursor = value
+        self.dirty_surface = True
+
+    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(bf.const.DEFAULT_CURSOR)
+
+    def do_on_get_focus(self):
+        self.cursor_timer.resume()
+        self._cursor_toggle(True)
+        self.set_cursor_position(len(self.get_text()))
+        self.old_key_repeat = pygame.key.get_repeat()
+        pygame.key.set_repeat(200, 50)
+
+    def do_on_lose_focus(self):
+        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())
+        self.cursor_position = position
+        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):
+        if not self.is_focused:
+            return
+        text = self.get_text()
+        cursor_position = self.cursor_position
+
+        if event.type == pygame.TEXTINPUT:
+            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,62 +1,114 @@
 from .button import Button
-from .indicator import Indicator,ToggleIndicator
-import pygame
+from .indicator import Indicator, ToggleIndicator
 import batFramework as bf
 from typing import Self
+import pygame
+
 
 class Toggle(Button):
-    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.add_child(self.indicator)
-        self.set_gap(int(max(4,self.get_content_width()/3)))
-        # self.set_gap()
-        # self.set_gap(20)
-
-    def set_gap(self,value:int|float)->Self:
-        if value < 0 : return self
+    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
+        super().__init__(text, callback)
+        self.add(self.indicator)
+        self.set_clip_children(False)
+        # 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)
+        self.dirty_surface = True
+        if do_callback and self.callback:
+            self.callback(self.value)
+        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
         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.value = not self.value
-        self.build()
-        if self.on_toggle : self.on_toggle(self.value)
-
-    def set_toggle_callback(self,callback)->Self:
-        self.on_toggle = callback
-        return self
 
-    def _build_layout(self)->None:
-        self.indicator.set_value(self.value)
-        
+    def toggle(self) -> None:
+        self.set_value(not self.value, do_callback=True)
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        if not self.text_rect:
+            self.text_rect.size = self._get_text_rect_required_size()
+        w, h = self.text_rect.size
+        outline_offset = self._get_outline_offset()
+
         size = (
-            0,
-            0,
-            self._text_rect.w + self.indicator.rect.w + self.gap,
-            max(self._text_rect.h, self.indicator.rect.h)
+            max(
+                self.indicator.rect.w,
+                w + self.font_object.point_size + (self.gap if self.text else 0),
+            ),
+            self.text_rect.h + outline_offset[1],
         )
-        
-        required_rect = self.inflate_rect_by_padding(size)
-        
-        if self.autoresize and (self.rect.size != required_rect.size) :
-            self.set_size(*required_rect.size)
-            return
-
-        required_rect = self.get_content_rect()
-        required_rect_rel = self.get_content_rect_rel()
-
-        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)
-        
+        return self.inflate_rect_by_padding((0, 0, *size)).size
+
+    def _build_layout(self) -> None:
+
+        gap = self.gap if self.text else 0
+
+        self.text_rect.size = self._get_text_rect_required_size()
+
+        outline_offset = self._get_outline_offset()
+
+        tmp_rect = pygame.FRect(
+            0, 0,
+            self.text_rect.w + gap + self.indicator.rect.w + outline_offset[0],
+            self.text_rect.h + outline_offset[1]
+        )
+
+        point_size = min(tmp_rect.h, self.font_object.point_size)
+        self.indicator.set_size_if_autoresize((point_size,point_size))
+
+        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_rect = self.get_padded_rect()
+        padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
+
+ 
+
+        self.align_text(tmp_rect, padded_relative, self.alignment)
+        self.text_rect.midleft = tmp_rect.midleft
+        if self.text:
+            match self.spacing:
+                case bf.spacing.MAX:
+                    gap = padded_relative.right - self.text_rect.right - self.indicator.rect.w
+                case bf.spacing.MIN:
+                    gap = 0
+
+        self.indicator.rect.x = self.rect.x + self.text_rect.right + gap
+        self.indicator.rect.centery = self.rect.y + padded_relative.top + self.text_rect.h // 2