batframework 1.0.8a9__py3-none-any.whl → 1.0.8a10__py3-none-any.whl

batFramework/gui/textInput.py

@@ -0,0 +1,247 @@
+import batFramework as bf
+from typing import Self, Callable
+from .label import Label
+from .interactiveWidget import InteractiveWidget
+import pygame
+
+def find_next_word(s: str, start_index: int) -> int:
+    length = len(s)
+    # Ensure the starting index is within the bounds of the string
+    if start_index < 0 or start_index >= length:
+        raise ValueError("Starting index is out of bounds")
+    index = start_index
+    # If the start_index is at a space, skip leading spaces
+    if s[index] in [' ','\n']:
+        while index < length and s[index]  in [' ','\n']:
+            index += 1
+        # If we've reached the end of the string
+        if index >= length:
+            return -1
+    else:
+        # If the start_index is within a word, move to the end of that word
+        while index < length and s[index] not in [' ','\n']:
+            index += 1
+        if index == length:
+            return index    
+    # Return the index of the start of the next word or -1 if no more words are found
+    return index if index < length else -1
+
+def find_prev_word(s: str, start_index: int) -> int:
+    if start_index <= 0 : return 0
+    length = len(s)
+    
+    # Ensure the starting index is within the bounds of the string
+    if start_index < 0 or start_index >= length:
+        raise ValueError("Starting index is out of bounds")
+    
+    index = start_index
+    
+    # If the start_index is at a space, skip trailing spaces
+    if s[index] in [' ', '\n']:
+        while index > 0 and s[index-1] in [' ', '\n']:
+            index -= 1
+        # If we've reached the beginning of the string
+        if index <= 0:
+            return 0 if s[0] not in [' ', '\n'] else -1
+    else:
+        # If the start_index is within a word, move to the start of that word
+        while index > 0 and s[index-1] not in [' ', '\n']:
+            index -= 1
+        if index == 0 and s[index] not in [' ', '\n']:
+            return 0
+    
+    # Return the index of the start of the previous word or -1 if no more words are found
+    return index if index > 0 or (index == 0 and s[0] not in [' ', '\n']) else -1
+
+
+class TextInput(Label, InteractiveWidget):
+    def __init__(self) -> None:
+        self.cursor_position = (0, 0)
+        self.old_key_repeat = (0, 0)
+        self.cursor_timer = bf.Timer(0.3, self._cursor_toggle, loop=True).start()
+        self.cursor_timer.pause()
+        self.show_cursor = False
+        self.on_modify: Callable[[str], str] = None
+        self.set_focusable(True)
+        self.set_outline_color("black")
+        super().__init__("")
+        self.alignment = bf.alignment.TOPLEFT
+
+    def set_modify_callback(self, callback: Callable[[str], str]) -> Self:
+        self.on_modify = callback
+        return self
+
+    def __str__(self) -> str:
+        return f"TextInput({repr(self.text)})"
+
+    def _cursor_toggle(self, value: bool | None = 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.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 get_line(self, line: int) -> str | None:
+        if line < 0:
+            return None
+        lines = self.text.split('\n')
+        if line >= len(lines):
+            return None
+        return lines[line]
+
+    def set_cursor_position(self, position: tuple[int, int]) -> Self:
+        x, y = position
+
+        lines = self.text.split('\n')
+        y = max(0, min(y, len(lines) - 1))
+        line_length = len(lines[y])
+        x = max(0, min(x, line_length))
+
+        self.cursor_position = (x, y)
+        self.show_cursor = True
+        self.dirty_shape = True
+        return self
+
+    def cursor_to_absolute(self, position: tuple[int, int]) -> int:
+        x, y = position
+
+        y = max(0, min(y, len(self.text.split('\n')) - 1))
+        lines = self.text.split('\n')
+        x = max(0, min(x, len(lines[y])))
+
+        absolute_position = sum(len(line) + 1 for line in lines[:y]) + x
+        return absolute_position
+
+    def absolute_to_cursor(self, absolute: int) -> tuple[int, int]:
+        text = self.text
+        lines = text.split('\n')
+        current_pos = 0
+
+        for line_no, line in enumerate(lines):
+            if absolute <= current_pos + len(line):
+                return (absolute - current_pos, line_no)
+            current_pos += len(line) + 1
+
+        return (len(lines[-1]), len(lines) - 1)
+
+    def do_handle_event(self, event):
+        if not self.is_focused:
+            return
+
+        if event.type not in [pygame.TEXTINPUT, pygame.KEYDOWN]:
+            return
+
+        text = self.get_text()
+        current = self.cursor_to_absolute(self.cursor_position)
+        if event.type == pygame.TEXTINPUT:
+            self.set_text(text[:current] + event.text + text[current:])
+            self.set_cursor_position(self.absolute_to_cursor(current + len(event.text)))
+        elif event.type == pygame.KEYDOWN:
+            pressed = pygame.key.get_pressed()
+            if event.key == pygame.K_ESCAPE:
+                self.lose_focus()
+            elif event.key == pygame.K_BACKSPACE:
+                if current > 0:
+                    self.set_text(text[:current - 1] + text[current:])
+                    self.set_cursor_position(self.absolute_to_cursor(current - 1))
+            elif event.key == pygame.K_DELETE:
+                if current < len(text):
+                    self.set_text(text[:current] + text[current + 1:])
+            elif event.key == pygame.K_RIGHT:
+                if self.cursor_to_absolute(self.cursor_position)>=len(self.text):
+                    return
+                if self.cursor_position[0] == len(self.get_line(self.cursor_position[1])):
+                    self.set_cursor_position((0, self.cursor_position[1] + 1))
+                else:
+                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
+                        index = find_next_word(self.text,current)
+                        if index ==-1 : index = current+1
+                        self.set_cursor_position(self.absolute_to_cursor(index))
+                    else:
+                        self.set_cursor_position(self.absolute_to_cursor(current + 1))
+            elif event.key == pygame.K_LEFT:
+
+
+                if self.cursor_position[0] == 0 and self.cursor_position[1] > 0:
+                    self.set_cursor_position((len(self.get_line(self.cursor_position[1] - 1)), self.cursor_position[1] - 1))
+                else:
+                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
+                        index = find_prev_word(self.text,current-1)
+                        if index ==-1 : index = current-1
+                        self.set_cursor_position(self.absolute_to_cursor(index))
+                    else:
+                        self.set_cursor_position(self.absolute_to_cursor(current - 1))
+            elif event.key == pygame.K_UP:
+                x, y = self.cursor_position
+                self.set_cursor_position((x, y - 1))
+            elif event.key == pygame.K_DOWN:
+                x, y = self.cursor_position
+                self.set_cursor_position((x, y + 1))
+            elif event.key == pygame.K_RETURN:
+                self.set_text(text[:current] + '\n' + text[current:])
+                self.set_cursor_position(self.absolute_to_cursor(current + 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
+
+        lines = self.text.split('\n')
+        line_x, line_y = self.cursor_position
+
+        cursor_y = self.padding[1] 
+        cursor_y += line_y * self.font_object.get_linesize()
+        cursor_x = self.padding[0]
+        cursor_x += self.font_object.size(lines[line_y][:line_x])[0] if line_x > 0 else 0
+
+        cursor_rect = pygame.Rect(cursor_x, cursor_y, 2, self.font_object.get_height())
+        pygame.draw.rect(self.surface, self.text_color, cursor_rect)
+
+    def paint(self) -> None:
+        super().paint()
+        self._paint_cursor()
+
+    # def set_alignment(self, alignment: bf.alignment) -> Self:
+    #     return self
+
+    # 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)
+    #     return

batFramework/gui/toggle.py

@@ -1,62 +1,112 @@
 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()
         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.get_min_required_size()[0],
+                self.text_rect.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
+        self.text_rect.size = self._get_text_rect_required_size()
+
+        #right part size
+        right_part_height = min(self.text_rect.h, self.font_object.point_size)
+        self.indicator.set_size_if_autoresize((right_part_height,right_part_height))
+
+        #join left and right
+        joined_rect = pygame.FRect(
+            0, 0, self.text_rect.w + gap + self.indicator.rect.w, self.text_rect.h 
         )
-        
-        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)
-        
+
+
+        if self.autoresize_h or self.autoresize_w:
+            target_rect = self.inflate_rect_by_padding(joined_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
+
+        # ------------------------------------ size is ok
+
+        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
+        padded_rect = self.get_padded_rect()
+        padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
+
+        self.align_text(joined_rect, padded_relative.move( offset), self.alignment)
+        self.text_rect.midleft = joined_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
+
+        pos = self.text_rect.move(
+                self.rect.x + gap -offset[0],
+                self.rect.y + (self.text_rect.h / 2) - (right_part_height/ 2) -offset[1],
+            ).topright
+        self.indicator.rect.topleft = pos