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

batFramework/gui/slider.py

@@ -11,11 +11,14 @@ class SliderHandle(Indicator, DraggableWidget):
     def __init__(self):
         super().__init__()
         self.set_color(bf.color.CLOUD_SHADE)
-
+        self.old_key_repeat: tuple = (0, 0)
+        self.parent : bf.ClickableWidget = self.parent
     def __str__(self) -> str:
         return "SliderHandle"
 
     def on_click_down(self, button: int) -> None:
+        if not self.parent.is_enabled(): 
+            return
         super().on_click_down(button)
         if button == 1:
             self.parent.get_focus()
@@ -27,6 +30,8 @@ class SliderHandle(Indicator, DraggableWidget):
     def do_on_drag(
         self, drag_start: tuple[float, float], drag_end: tuple[float, float]
     ) -> None:
+        if not self.parent.is_enabled(): 
+            return
         super().do_on_drag(drag_start, drag_end)
         m: Meter = self.parent.meter
         r = m.get_padded_rect()
@@ -42,21 +47,20 @@ class SliderHandle(Indicator, DraggableWidget):
 
 
 class SliderMeter(Meter, InteractiveWidget):
-
     def __str__(self) -> str:
         return "SliderMeter"
 
     def on_click_down(self, button: int) -> None:
+        if not self.parent.is_enabled(): 
+            return
         if button == 1:
             self.parent.get_focus()
             r = self.get_root()
             if r:
                 pos = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())[0]
                 self.parent.set_value(self.parent.position_to_value(pos))
-
         self.do_on_click_down(button)
 
-
 class Slider(Button):
     def __init__(self, text: str, default_value: float = 1.0) -> None:
         super().__init__(text, None)
@@ -68,8 +72,6 @@ class Slider(Button):
         self.add(self.meter, self.handle)
         self.meter.set_debug_color(bf.color.RED)
         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)
@@ -84,22 +86,14 @@ class Slider(Button):
         self.gap = value
         return self
 
-    def get_min_required_size(self) -> tuple[float, float]:
-        gap = self.gap if self.text else 0
-        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
-        return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.rect.w, h)).size
+    def do_on_get_focus(self) -> None:
+        super().do_on_get_focus()
+        self.old_key_repeat = pygame.key.get_repeat()
+        pygame.key.set_repeat(200, 50)
+
+    def do_on_lose_focus(self) -> None:
+        super().do_on_lose_focus()
+        pygame.key.set_repeat(*self.old_key_repeat)
 
     def set_spacing(self, spacing: bf.spacing) -> Self:
         if spacing == self.spacing:
@@ -114,10 +108,12 @@ class Slider(Button):
 
     def set_range(self, range_min: float, range_max: float) -> Self:
         self.meter.set_range(range_min, range_max)
+        self.dirty_shape = True
         return self
 
     def set_step(self, step: float) -> Self:
         self.meter.set_step(step)
+        self.dirty_shape = True
         return self
 
     def set_value(self, value, no_callback: bool = False) -> Self:
@@ -132,14 +128,16 @@ class Slider(Button):
         return self.meter.get_value()
 
     def do_on_key_down(self, key):
+        if not self.is_enabled(): 
+            return
         if key == pygame.K_RIGHT:
             self.set_value(self.meter.get_value() + self.meter.step)
-            bf.AudioManager().play_sound(self.click_down_sound)
         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 not self.is_enabled(): 
+            return
         if button == 1:
             self.get_focus()
 
@@ -151,8 +149,6 @@ class Slider(Button):
         value_range = self.meter.get_range()
         value = round(value / self.meter.step) * self.meter.step
         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)
@@ -174,31 +170,34 @@ class Slider(Button):
         value = self.meter.min_value + position_ratio * value_range
         return round(value / self.meter.step) * self.meter.step
 
-    def _build_layout(self) -> None:
-
+    def get_min_required_size(self) -> tuple[float, float]:
         gap = self.gap if self.text else 0
+        if not self.text_rect:
+            self.text_rect.size = self._get_text_rect_required_size()
+        w, h = self.text_rect.size
+        return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.get_min_required_size()[1], h)).size
 
-        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,
-        }
+    def _build_layout(self) -> None:
 
-        self.text_rect.size = self._render_font(params).get_size()
+        gap = self.gap if self.text else 0
+        self.text_rect.size = self._get_text_rect_required_size()
 
-        meter_size = [self.text_rect.h * 10, self.font_object.point_size]
+        #right part size
+        meter_width = self.text_rect.h * 10
         if not self.autoresize_w:
-            meter_size[0] = self.get_padded_width() - self.text_rect.w - gap
+            meter_width = self.get_padded_width() - self.text_rect.w - gap
+        right_part_height = min(self.text_rect.h, self.font_object.point_size)
+        self.meter.set_size_if_autoresize((meter_width,right_part_height))
+        self.handle.set_size_if_autoresize((None,right_part_height))
+
 
-        tmp_rect = pygame.FRect(
-            0, 0, self.text_rect.w + gap + meter_size[0], self.text_rect.h
+        #join left and right
+        joined_rect = pygame.FRect(
+            0, 0, self.text_rect.w + gap + meter_width, self.text_rect.h
         )
 
         if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding(tmp_rect)
+            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:
@@ -209,36 +208,31 @@ class Slider(Button):
                 return
 
         # ------------------------------------ size is ok
-        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()]
+        
 
-        self.handle.set_size_if_autoresize(handle_size)
+        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(tmp_rect, padded, self.alignment)
-        self.text_rect.midleft = tmp_rect.midleft
+        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.w - self.text_rect.w - self.meter.rect.w
+                    gap = padded_relative.right - self.text_rect.right - self.meter.rect.w
                 case bf.spacing.MIN:
                     gap = 0
 
         # 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,
+        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.meter.rect.topleft = pos
         # 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)

batFramework/gui/textInput.py

@@ -4,27 +4,77 @@ 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
-        self.old_key_repeat: tuple = (0, 0)
+        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: bool = False
+        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({self.text})"
+        return f"TextInput({repr(self.text)})"
 
-    def _cursor_toggle(self, value: bool = None):
+    def _cursor_toggle(self, value: bool | None = None):
         if value is None:
             value = not self.show_cursor
         self.show_cursor = value
@@ -42,10 +92,9 @@ class TextInput(Label, InteractiveWidget):
         pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
 
     def do_on_get_focus(self):
-        self.old_key_repeat = pygame.key.get_repeat()
         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):
@@ -53,42 +102,105 @@ class TextInput(Label, InteractiveWidget):
         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
+    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_surface = True
-        if self.text_rect.w > self.get_padded_width():
-            self.dirty_shape = 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
-        text = self.get_text()
-        cursor_position = self.cursor_position
 
+        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[:cursor_position] + event.text + text[cursor_position:])
-            self.set_cursor_position(cursor_position + 1)
+            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 cursor_position > 0:
-                    self.set_text(text[: cursor_position - 1] + text[cursor_position:])
-                    self.set_cursor_position(cursor_position - 1)
-
+                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:
-                self.set_cursor_position(cursor_position + 1)
-
+                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:
-                self.set_cursor_position(cursor_position - 1)
 
+
+                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:
@@ -104,34 +216,32 @@ class TextInput(Label, InteractiveWidget):
     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
+        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 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
+    # 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

@@ -6,13 +6,14 @@ 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
         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:
@@ -53,51 +54,32 @@ class Toggle(Button):
 
     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
+            self.text_rect.size = self._get_text_rect_required_size()
         size = (
             max(
-                self.indicator.rect.w,
-                w + self.font_object.point_size + (self.gap if self.text else 0),
+                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()
 
-        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
+        #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))
 
-        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
+        #join left and right
+        joined_rect = pygame.FRect(
+            0, 0, self.text_rect.w + gap + self.indicator.rect.w, self.text_rect.h 
         )
 
+
         if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding(tmp_rect)
+            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:
@@ -107,20 +89,24 @@ class Toggle(Button):
                 self.build()
                 return
 
-        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
+        # ------------------------------------ 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
 
-        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
+                    gap = padded_relative.right - self.text_rect.right - self.indicator.rect.w
                 case bf.spacing.MIN:
                     gap = 0
 
-        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,
+        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