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

batFramework/gui/layout.py

@@ -1,14 +1,15 @@
 import batFramework as bf
 from .widget import Widget
 from .constraints.constraints import *
-from typing import Self, TYPE_CHECKING
+from typing import Self, TYPE_CHECKING,override
+from abc import ABC,abstractmethod
 import pygame
 
 if TYPE_CHECKING:
     from .container import Container
 
 
-class Layout:
+class Layout(ABC):
     def __init__(self, parent: "Container" = None):
         self.parent = parent
         self.child_constraints: list[Constraint] = []
@@ -48,18 +49,10 @@ class Layout:
         return target_size
 
     def focus_next_child(self) -> None:
-        l = self.parent.get_interactive_children()
-        self.parent.focused_index = min(self.parent.focused_index + 1, len(l) - 1)
-        focused = l[self.parent.focused_index]
-        focused.get_focus()
-        self.scroll_to_widget(focused)
+        pass
 
     def focus_prev_child(self) -> None:
-        l = self.parent.get_interactive_children()
-        self.parent.focused_index = max(self.parent.focused_index - 1, 0)
-        focused = l[self.parent.focused_index]
-        focused.get_focus()
-        self.scroll_to_widget(focused)
+        pass
 
     def scroll_to_widget(self, widget: Widget) -> None:
         padded = self.parent.get_padded_rect()
@@ -74,7 +67,23 @@ class Layout:
         pass
 
 
-class Column(Layout):
+class SingleAxisLayout(Layout):
+    def focus_next_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        self.parent.focused_index = min(self.parent.focused_index + 1, len(l) - 1)
+        focused = l[self.parent.focused_index]
+        focused.get_focus()
+        self.scroll_to_widget(focused)
+
+    def focus_prev_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        self.parent.focused_index = max(self.parent.focused_index - 1, 0)
+        focused = l[self.parent.focused_index]
+        focused.get_focus()
+        self.scroll_to_widget(focused)
+
+
+class Column(SingleAxisLayout):
     def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
         super().__init__()
         self.gap = gap
@@ -157,7 +166,7 @@ class Column(Layout):
                 self.parent.clamp_scroll()
 
 
-class Row(Layout):
+class Row(SingleAxisLayout):
     def __init__(self, gap: int = 0, spacing: bf.spacing = bf.spacing.MANUAL):
         super().__init__()
         self.gap = gap

batFramework/gui/meter.py

@@ -17,9 +17,11 @@ class Meter(Shape):
         self.snap: bool = False
         self.value = self.max_value
         self.content = Shape((0, 0)).set_color(bf.color.BLUE)
+        self.content.set_debug_color("cyan")
         self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
         self.add(self.content)
-        self.set_padding(1)
+        self.set_padding(4)
+        self.set_color("gray20")
         self.set_outline_width(1)
         self.set_outline_color(bf.color.BLACK)
         self.set_debug_color("pink")
@@ -38,18 +40,19 @@ class Meter(Shape):
                 f"[Warning] : minimum value {range_min} is greater than or equal to maximum value {range_max}"
             )
             return self
-        self.min_value, self.max_value = range_min, range_max
+        self.min_value = range_min
+        self.max_value = range_max
         self.dirty_shape = True
 
     def get_debug_outlines(self):
         yield from super().get_debug_outlines()
-        yield from self.content.get_debug_outlines()
+        # yield from self.content.get_debug_outlines()
 
     def set_value(self, value: float) -> Self:
         value = max(self.min_value, min(self.max_value, value))
         value = round(value / self.step) * self.step
-        self.value = value
-        self.dirty_surface = True
+        self.value = round(value,10)
+        self.dirty_shape = True
         return self
 
     def get_value(self) -> float:
@@ -59,12 +62,12 @@ class Meter(Shape):
         return self.max_value - self.min_value
 
     def get_ratio(self) -> float:
-        return self.value / (self.max_value - self.min_value)
+        return (self.value-self.min_value) / (self.max_value - self.min_value)
 
     def _build_content(self) -> None:
         width = self.get_padded_width() * self.get_ratio()
         self.content.set_size((width, self.get_padded_height()))
-        self.content.set_position(*self.get_padded_rect().topleft)
+        self.content.rect.topleft = self.get_padded_rect().topleft
 
     def build(self) -> None:
         super().build()

batFramework/gui/radioButton.py

@@ -7,7 +7,7 @@ class RadioVariable: ...
 
 
 class RadioButton(Toggle):
-    def __init__(self, text: str, radio_value: Any = None) -> None:
+    def __init__(self, text: str = "", radio_value: Any = None) -> None:
         super().__init__(text, None, False)
         self.radio_value: Any = (
             radio_value if radio_value is not None else text if text else None

batFramework/gui/shape.py

@@ -43,15 +43,10 @@ class Shape(Widget):
     def set_relief(self, relief: int) -> Self:
         if relief < 0:
             return self
-        if self.relief == relief:
-            return self
+        self.dirty_shape = self.relief != relief
         self.relief = relief
-        self.dirty_shape = True
         return self
 
-    def get_relief(self) -> int:
-        return self.relief
-
     def set_texture(
         self, surface: pygame.SurfaceType, subsize: tuple[int, int] | None = None
     ) -> Self:
@@ -223,8 +218,8 @@ class Shape(Widget):
         return pygame.FRect(0, self.rect.h - self.relief, self.rect.w, self.relief)
 
     def _paint_shape(self) -> None:
+        self.surface.fill((0, 0, 0, 0))
         if self.relief!=0:
-            self.surface.fill((0, 0, 0, 0))
             self.surface.fill(self.shadow_color, self._get_base_rect())
             self.surface.fill(self.color, self._get_elevated_rect())
         else:
@@ -242,27 +237,10 @@ class Shape(Widget):
             pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
 
     def _paint_outline(self) -> None:
-        if self.relief:
-            pygame.draw.rect(
-                self.surface,
-                self.outline_color,
-                (
-                    0,
-                    self.relief - self.get_relief(),
-                    self.rect.w,
-                    self.rect.h - self.relief,
-                ),
-                self.outline_width,
-            )
         pygame.draw.rect(
             self.surface,
             self.outline_color,
-            (
-                0,
-                self.relief - self.get_relief(),
-                self.rect.w,
-                self.rect.h - (self.relief - self.get_relief()),
-            ),
+            self._get_elevated_rect(),
             self.outline_width,
         )
 

batFramework/gui/slider.py

@@ -12,11 +12,13 @@ class SliderHandle(Indicator, DraggableWidget):
         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()
@@ -28,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()
@@ -43,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)
@@ -92,13 +95,6 @@ class Slider(Button):
         super().do_on_lose_focus()
         pygame.key.set_repeat(*self.old_key_repeat)
 
-    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.rect.w, h)).size
-
     def set_spacing(self, spacing: bf.spacing) -> Self:
         if spacing == self.spacing:
             return self
@@ -112,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:
@@ -130,12 +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)
         elif key == pygame.K_LEFT:
             self.set_value(self.meter.get_value() - self.meter.step)
 
     def do_on_click_down(self, button) -> None:
+        if not self.is_enabled(): 
+            return
         if button == 1:
             self.get_focus()
 
@@ -168,22 +170,34 @@ class Slider(Button):
         value = self.meter.min_value + position_ratio * value_range
         return round(value / self.meter.step) * self.meter.step
 
+    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
+
     def _build_layout(self) -> None:
 
         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:
@@ -194,14 +208,14 @@ class Slider(Button):
                 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.meter.set_size_if_autoresize(meter_size)
-
-        self.align_text(tmp_rect, padded_relative, 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:
@@ -212,17 +226,13 @@ class Slider(Button):
 
         # 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
@@ -44,7 +94,6 @@ class TextInput(Label, InteractiveWidget):
     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)
 
@@ -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