batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

batFramework/gui/slider.py

@@ -1,69 +1,94 @@
 import batFramework as bf
-from .meter import Meter
+from .meter import BarMeter
 from .button import Button
 from .indicator import *
-from .meter import Meter
+from .meter import BarMeter
 from .shape import Shape
 from .interactiveWidget import InteractiveWidget
 
-
 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
+        self.set_click_mask(1)
     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:
+    def on_click_down(self, button: int) -> bool:
+        if not self.parent.is_enabled: 
+            return True
+        res = super().on_click_down(button)
+        if res : 
             self.parent.get_focus()
-
-    def on_exit(self) -> None:
-        self.is_hovered = False
-        self.do_on_exit()
-
+        return res
+    
+    def on_exit(self):
+        before = self.is_clicked_down
+        super().on_exit()
+        self.is_clicked_down = before
+    
     def do_on_drag(
         self, drag_start: tuple[float, float], drag_end: tuple[float, float]
     ) -> None:
-        if not self.parent.is_enabled(): 
+        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()
-        position = self.rect.centerx
+        m: BarMeter = self.parent.meter
+        r = m.get_inner_rect()
+
+        position = self.rect.centerx if self.parent.axis == bf.axis.HORIZONTAL else self.rect.centery
         self.rect.clamp_ip(r)
         # Adjust handle position to value
         new_value = self.parent.position_to_value(position)
         self.parent.set_value(new_value)
-        self.rect.centerx = self.parent.value_to_position(new_value)
+        if self.parent.axis == bf.axis.HORIZONTAL:
+            self.rect.centerx = self.parent.value_to_position(new_value)
+        else:
+            self.rect.centery = self.parent.value_to_position(new_value)
 
     def top_at(self, x, y):
         return Widget.top_at(self, x, y)
 
-
-class SliderMeter(Meter, InteractiveWidget):
+class SliderMeter(BarMeter, 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))
+    def __init__(self, min_value = 0, max_value = 1, step = 0.1):
+        super().__init__(min_value, max_value, step)
+        self.set_padding(0)
+
+    def get_min_required_size(self):
+        size = list(super().get_min_required_size())
+        if self.parent.axis == bf.axis.HORIZONTAL:
+            size[0] = size[1]*3
+        else:
+            size[1] = size[0]*3
+        return self.resolve_size(size)
+
+    def on_click_down(self, button: int) -> bool:
+        if not self.parent.is_enabled: 
+            return False
+        if button != 1:
+            return False
+        
+        self.parent.get_focus()
+        pos = self.parent_layer.camera.screen_to_world(pygame.mouse.get_pos())
+        if self.parent.axis == bf.axis.HORIZONTAL:
+            pos = pos[0]
+        else:
+            pos = pos[1]
+        new_value = self.parent.position_to_value(pos)
+        self.parent.set_value(new_value)
         self.do_on_click_down(button)
+        return True
 
 class Slider(Button):
+
     def __init__(self, text: str, default_value: float = 1.0) -> None:
         super().__init__(text, None)
+        self.axis : bf.axis = bf.axis.HORIZONTAL
         self.gap: float | int = 0
         self.spacing: bf.spacing = bf.spacing.MANUAL
         self.modified_callback : Callable[[float],Any] = None
@@ -73,6 +98,19 @@ class Slider(Button):
         self.meter.set_debug_color(bf.color.RED)
         self.set_value(default_value, True)
 
+    def set_tooltip_text(self, text):
+        return super().set_tooltip_text(text)
+
+    def set_fill_color(self,color)->Self:
+        self.meter.content.set_color(color)
+        return self
+    
+    def set_axis(self,axis:bf.axis)->Self:
+        self.axis = axis
+        self.meter.set_axis(axis)
+        self.dirty_shape = True
+        return self
+    
     def set_visible(self, value: bool) -> Self:
         self.handle.set_visible(value)
         self.meter.set_visible(value)
@@ -122,21 +160,39 @@ class Slider(Button):
             self.dirty_shape = True
         if self.modified_callback and (not no_callback):
             self.modified_callback(self.meter.value)
+            self.handle.set_tooltip_text(str(self.get_value()))
+            self.meter.set_tooltip_text(str(self.get_value()))
+
         return self
 
     def get_value(self) -> float:
         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 on_key_down(self, key):
+        if super().on_key_down(key):
+            return True
+        if not self.is_enabled: 
+            return False
+        if self.axis == bf.axis.HORIZONTAL:
+            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)
+            else:
+                return False
+            return True
+        else:
+            if key == pygame.K_UP:
+                self.set_value(self.meter.get_value() + self.meter.step)
+            elif key == pygame.K_DOWN:
+                self.set_value(self.meter.get_value() - self.meter.step)
+            else:
+                return False
+
+            return True
 
     def do_on_click_down(self, button) -> None:
-        if not self.is_enabled(): 
+        if not self.is_enabled: 
             return
         if button == 1:
             self.get_focus()
@@ -145,98 +201,197 @@ class Slider(Button):
         """
         Converts a value to a position on the meter, considering the step size.
         """
-        rect = self.meter.get_padded_rect()
+        rect = self.meter.get_inner_rect()
         value_range = self.meter.get_range()
         value = round(value / self.meter.step) * self.meter.step
         position_ratio = (value - self.meter.min_value) / value_range
-        return (
-            rect.left
-            + (self.handle.rect.w / 2)
-            + position_ratio * (rect.width - self.handle.rect.w)
-        )
-
+        if self.axis == bf.axis.HORIZONTAL:
+            return (
+                rect.left
+                + (self.handle.rect.w / 2)
+                + position_ratio * (rect.width - self.handle.rect.w)
+            )
+        else:
+            return (
+                rect.bottom
+                - (self.handle.rect.h / 2)
+                - position_ratio * (rect.height - self.handle.rect.h)
+            )
+            
     def position_to_value(self, position: float) -> float:
         """
         Converts a position on the meter to a value, considering the step size.
         """
-        handle_half = self.handle.rect.w / 2
-        rect = self.meter.get_padded_rect()
-        position = max(rect.left + handle_half, min(position, rect.right - handle_half))
+        rect = self.meter.get_inner_rect()
+        if self.axis == bf.axis.HORIZONTAL:
+            if self.rect.w == self.handle.rect.w:
+                position_ratio = 0
+            else:
+                handle_half = self.handle.rect.w // 2
+                position = max(rect.left + handle_half, min(position, rect.right - handle_half))
+                position_ratio = (position - rect.left - handle_half) / (
+                    rect.width - self.handle.rect.w
+                )
+        else:
+            if self.rect.h == self.handle.rect.h:
+                position_ratio = 0
+            else:
+                handle_half = self.handle.rect.h // 2
+                position = max(rect.top + handle_half, min(position, rect.bottom - handle_half))
+                # Flip ratio vertically: bottom is min, top is max
+                position_ratio = (rect.bottom - position - handle_half) / (
+                    rect.height - self.handle.rect.h
+                )
 
-        position_ratio = (position - rect.left - handle_half) / (
-            rect.width - self.handle.rect.w
-        )
         value_range = self.meter.get_range()
         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
-        h+=self.unpressed_relief
-        return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.get_min_required_size()[1], h)).size
-
-    def _build_layout(self) -> None:
+        """
+        Calculates the minimum required size for the slider, considering the text, meter, and axis.
 
+        Returns:
+            tuple[float, float]: The width and height of the minimum required size.
+        """
         gap = self.gap if self.text else 0
-        self.text_rect.size = self._get_text_rect_required_size()
-
-        #right part size
-        meter_width = self.text_rect.h * 10
-        if not self.autoresize_w:
-            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))
+        text_width, text_height = self._get_text_rect_required_size() if self.text else (0, 0)
+        meter_width, meter_height = self.meter.resolve_size(self.meter.get_min_required_size())
 
+        if self.axis == bf.axis.HORIZONTAL:
+            width = text_width + gap + meter_width 
+            height = max(text_height, meter_height)
+        else:
+            width = max(text_width, meter_width)
+            height = text_height + gap + meter_height
 
-        #join left and right
-        joined_rect = pygame.FRect(
-            0, 0, self.text_rect.w + gap + meter_width, self.text_rect.h
-        )
+        height += self.unpressed_relief
+        return self.expand_rect_with_padding((0, 0, width, height)).size
 
-        if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding(joined_rect)
-            target_rect.h += self.unpressed_relief
-            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
-        
+    def _build_composed_layout(self) -> None:
+        """
+        Builds the composed layout for the slider, including the meter and handle.
+        This method adjusts the sizes and positions of the meter and handle based on the slider's axis,
+        autoresize conditions, and spacing settings. It ensures the slider's components are properly aligned
+        and sized within the slider's padded rectangle.
+        """
+        self.text_rect.size = self._get_text_rect_required_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)
+        size_changed = False
+        gap = self.gap if self.text else 0
 
-        self.align_text(joined_rect, padded_relative.move( offset), self.alignment)
-        self.text_rect.midleft = joined_rect.midleft
+        full_rect = self.text_rect.copy()
 
-        if self.text:
-            match self.spacing:
-                case bf.spacing.MAX:
-                    gap = padded_relative.right - self.text_rect.right - self.meter.rect.w
-                case bf.spacing.MIN:
-                    gap = 0
 
-        # place meter
+        # Resolve the meter's size based on the axis and autoresize conditions
+        if self.axis == bf.axis.HORIZONTAL:
+            meter_width,meter_height = self.meter.get_min_required_size()
+            if not self.autoresize_w:
+                meter_width = self.get_inner_width() - gap - self.text_rect.w 
+            meter_width,meter_height = self.meter.resolve_size((meter_width,meter_height))
 
-        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
+            full_rect.w = max(self.get_inner_width(), meter_width + (gap + self.text_rect.w if self.text else 0))
+            self.meter.set_size((meter_width, meter_height))
+            full_rect.h = max(meter_height, self.text_rect.h if self.text else meter_height)
 
-        x = self.value_to_position(self.meter.value)
-        r = self.meter.get_padded_rect()
-        self.handle.set_center(x, r.centery)
+        else:  # VERTICAL
+            meter_width, meter_height = self.meter.get_min_required_size()
+            if not self.autoresize_h:
+                meter_height = self.get_inner_height() - gap - self.text_rect.h
+            meter_width, meter_height = self.meter.resolve_size((meter_width, meter_height))
+
+            full_rect.h =  meter_height + (gap + self.text_rect.h if self.text else 0)
+            self.meter.set_size((meter_width, meter_height))
+            full_rect.w = max(meter_width, self.text_rect.w if self.text else meter_width)
+
+
+        # Inflate the rect by padding and resolve the target size
+        full_rect.h += self.unpressed_relief
+        inflated = self.expand_rect_with_padding((0, 0, *full_rect.size)).size
+
+        target_size = self.resolve_size(inflated)
+
+
+        # Update the slider's size if it doesn't match the target size
+        if self.rect.size != target_size:
+            self.set_size(target_size)
+            size_changed = True
+
+        # Adjust the handle size based on the meter's size
+        if self.axis == bf.axis.HORIZONTAL:
+            handle_size = self.meter.get_inner_height() 
+            self.handle.set_size(self.handle.resolve_size((handle_size, handle_size)))
+        else:
+            handle_size = self.meter.get_inner_width() 
+            self.handle.set_size(self.handle.resolve_size((handle_size, handle_size)))
+
+        self._align_composed()
+        return size_changed
+
+    def _align_composed(self):
+
+        if not self.text:
+            self.text_rect.size = (0,0)
+        full_rect = self.get_local_inner_rect()
+        left_rect = self.text_rect
+        right_rect = self.meter.rect.copy()
+
+
+
+        if self.axis == bf.axis.HORIZONTAL:
+            gap = {
+                bf.spacing.MIN: 0,
+                bf.spacing.HALF: (full_rect.width - left_rect.width - right_rect.width) // 2,
+                bf.spacing.MAX: full_rect.width - left_rect.width - right_rect.width,
+                bf.spacing.MANUAL: self.gap
+            }.get(self.spacing, 0)
+
+            gap = max(0, gap)
+            combined_width = left_rect.width + right_rect.width + gap
+
+            group_x = {
+                bf.alignment.LEFT: full_rect.left,
+                bf.alignment.MIDLEFT: full_rect.left,
+                bf.alignment.RIGHT: full_rect.right - combined_width,
+                bf.alignment.MIDRIGHT: full_rect.right - combined_width,
+                bf.alignment.CENTER: full_rect.centerx - combined_width // 2
+            }.get(self.alignment, full_rect.left)
+
+            left_rect.x, right_rect.x = group_x, group_x + left_rect.width + gap
+            left_rect.centery = right_rect.centery = full_rect.centery
+
+        else:  # VERTICAL
+            gap = {
+                bf.spacing.MIN: 0,
+                bf.spacing.HALF: (full_rect.height - left_rect.height - right_rect.height) // 2,
+                bf.spacing.MAX: full_rect.height - left_rect.height - right_rect.height,
+                bf.spacing.MANUAL: self.gap
+            }.get(self.spacing, 0)
+
+            gap = max(0, gap)
+            combined_height = left_rect.height + right_rect.height + gap
+
+            group_y = {
+                bf.alignment.TOP: full_rect.top,
+                bf.alignment.MIDTOP: full_rect.top,
+                bf.alignment.BOTTOM: full_rect.bottom - combined_height,
+                bf.alignment.MIDBOTTOM: full_rect.bottom - combined_height,
+                bf.alignment.CENTER: full_rect.centery - combined_height // 2
+            }.get(self.alignment, full_rect.top)
+
+            left_rect.y, right_rect.y = group_y, group_y + left_rect.height + gap
+            left_rect.centerx = right_rect.centerx = full_rect.centerx
+
+        # Push text to local, push shape to world
+        self.text_rect = left_rect
+        right_rect.move_ip(*self.rect.topleft)
+        self.meter.set_position(*right_rect.topleft)
+
+        # Position the handle based on the current value
+        if self.axis == bf.axis.HORIZONTAL:
+            self.handle.set_center(self.value_to_position(self.meter.value), self.meter.rect.centery)
+        else:
+            self.handle.set_center(self.meter.rect.centerx, self.value_to_position(self.meter.value))
 
-        # self.handle.set_center(x,self.rect.top)
+    def _build_layout(self) -> None:
+        return self._build_composed_layout()

batFramework/gui/syncedVar.py

@@ -0,0 +1,49 @@
+from .widget import Widget
+from typing import Callable, Any, Self
+
+class SyncedVar:
+    def __init__(self, value=None):
+        self._value: Any = value
+        self.modify_callback: Callable[[Any], Any] | None = None
+        self._bound_widgets: set[tuple[Widget, Callable[[Any], Any]]] = set()
+
+    def set_modify_callback(self, callback : Callable[[Any], Any]) -> Self:
+        self.modify_callback = callback
+        return self
+
+    def bind_widget(self, widget: Widget, update_callback: Callable[[Any], Any]) -> Self:
+        """
+        Binds a widget to the SyncedVar. The widget must provide an update_callback
+        function that will be called whenever the value changes.
+        """
+        self._bound_widgets.add((widget, update_callback))
+        self._update_widgets()
+        return self
+
+    def unbind_widget(self, widget: Widget)->Self:
+        """
+        Unbinds a widget from the SyncedVar.
+        """
+        self._bound_widgets = {
+            (w, cb) for w, cb in self._bound_widgets if w != widget
+        }
+        return self
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, new_value):
+        if self._value != new_value:
+            self._value = new_value
+            self._update_widgets()
+        if self.modify_callback is not None:
+            self.modify_callback(new_value)
+
+    def _update_widgets(self):
+        """
+        Calls the update callback for all bound widgets.
+        """
+        for _, update_callback in self._bound_widgets:
+            update_callback(self._value)

batFramework/gui/textInput.py

@@ -58,7 +58,7 @@ 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.2, self._cursor_toggle, loop=True).start()
+        self.cursor_timer = bf.Timer(0.2, self._cursor_toggle, loop=-1).start()
         self.cursor_timer.pause()
         self.show_cursor = False
         self.on_modify: Callable[[str], str] = None
@@ -72,7 +72,7 @@ class TextInput(Label, InteractiveWidget):
         return self
 
     def __str__(self) -> str:
-        return f"TextInput({repr(self.text)})"
+        return f"TextInput"
 
     def _cursor_toggle(self, value: bool | None = None):
         if value is None:
@@ -82,8 +82,9 @@ class TextInput(Label, InteractiveWidget):
 
     def do_on_click_down(self, button):
         if button != 1:
-            return
+            return False
         self.get_focus()
+        return True
 
     def do_on_enter(self):
         pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_IBEAM)
@@ -111,11 +112,18 @@ class TextInput(Label, InteractiveWidget):
         return lines[line]
 
     def get_debug_outlines(self):
-        if self.visible:
-            offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-            yield (self.text_rect.move(self.rect.x - offset[0] - self.scroll.x,self.rect.y - offset[1] - self.scroll.y), "purple")
         yield from super().get_debug_outlines()
-        yield (self.get_cursor_rect().move(-self.scroll+self.rect.topleft),"green")
+        if self.visible:
+            # offset = self._get_outline_offset() if self.show_text_outline else (0,0)
+            # yield (self.text_rect.move(self.rect.x - offset[0] - self.scroll.x,self.rect.y - offset[1] - self.scroll.y), "purple")
+            yield (self.get_cursor_rect().move(-self.scroll+self.rect.topleft),"green")
+
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        size = self._get_text_rect_required_size()
+        return self.expand_rect_with_padding(
+            (0, 0,size[0]+self.get_cursor_rect().w,size[1])
+        ).size
 
 
     def set_cursor_position(self, position: tuple[int, int]) -> Self:
@@ -127,9 +135,9 @@ class TextInput(Label, InteractiveWidget):
         x = max(0, min(x, line_length))
         self.show_cursor = True
         self.cursor_position = (x,y)
-        self.dirty_surface = True
+        self.apply_post_updates(skip_draw=True)
         offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-        padded = self.get_padded_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
+        padded = self.get_inner_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
         self.align_text(self.text_rect,padded,self.alignment)
         return self
 
@@ -142,11 +150,13 @@ class TextInput(Label, InteractiveWidget):
 
         height = self.font_object.get_linesize()
 
-        cursor_y = self.get_padded_rect().__getattribute__(self.alignment.value)[1] - self.rect.top
+        cursor_y = self.get_inner_rect().__getattribute__(self.alignment.value)[1] - self.rect.top
         cursor_y += line_y * height
         cursor_x = self.text_rect.x
         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, 1, height)
+        cursor_rect = pygame.Rect(cursor_x, cursor_y, 1, height-1)
+        offset = self._get_outline_offset()
+        cursor_rect.move_ip(offset[0] if self.cursor_position[0] >0 else 0,offset[1] if self.cursor_position[1] > 0 else 0)
         return cursor_rect
 
     def cursor_to_absolute(self, position: tuple[int, int]) -> int:
@@ -183,7 +193,6 @@ class TextInput(Label, InteractiveWidget):
             # Insert text at the current cursor position
             self.set_text(f"{text[:current_pos]}{event.text}{text[current_pos:]}")
             self.set_cursor_position(self.absolute_to_cursor(current_pos + len(event.text)))
-
         elif event.type == pygame.KEYDOWN:
             match event.key:
                 case pygame.K_ESCAPE:
@@ -191,34 +200,48 @@ class TextInput(Label, InteractiveWidget):
 
                 case pygame.K_BACKSPACE if current_pos > 0:
                     # Remove the character before the cursor
-                    self.set_text(f"{text[:current_pos - 1]}{text[current_pos:]}")
-                    self.set_cursor_position(self.absolute_to_cursor(current_pos - 1))
+                    delta = current_pos-1
+                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
+                        delta = find_prev_word(self.text,current_pos-1)
+                        if delta <0: delta = 0
+                        
+                    self.set_text(f"{text[:delta]}{text[current_pos:]}")
+                    self.set_cursor_position(self.absolute_to_cursor(delta))
+                    self._cursor_toggle(True)
 
                 case pygame.K_DELETE if current_pos < len(text):
                     # Remove the character at the cursor
                     self.set_text(f"{text[:current_pos]}{text[current_pos + 1:]}")
+                    self._cursor_toggle(True)
 
                 case pygame.K_RIGHT:
                     if current_pos < len(text):
                         self.handle_cursor_movement(pressed, current_pos, direction="right")
-
+                    self._cursor_toggle(True)
+                    
                 case pygame.K_LEFT:
                     if current_pos > 0:
                         self.handle_cursor_movement(pressed, current_pos, direction="left")
+                    self._cursor_toggle(True)
 
                 case pygame.K_UP:
                     # Move cursor up one line
                     self.set_cursor_position((self.cursor_position[0], self.cursor_position[1] - 1))
+                    self._cursor_toggle(True)
 
                 case pygame.K_DOWN:
                     # Move cursor down one line
                     self.set_cursor_position((self.cursor_position[0], self.cursor_position[1] + 1))
+                    self._cursor_toggle(True)
 
                 case pygame.K_RETURN:
                     # Insert a newline at the current cursor position
                     self.set_text(f"{text[:current_pos]}\n{text[current_pos:]}")
                     self.set_cursor_position(self.absolute_to_cursor(current_pos + 1))
+                    self._cursor_toggle(True)
                 case _ :
+                    if event.unicode:
+                        event.consumed = True
                     return
 
         event.consumed = True
@@ -249,7 +272,8 @@ class TextInput(Label, InteractiveWidget):
         cursor_rect = self.get_cursor_rect()
         cursor_rect.move_ip(-self.scroll)
         
-        pygame.draw.rect(self.surface, bf.color.CLOUD, cursor_rect.inflate(2,2))
+        if self.show_text_outline:
+            pygame.draw.rect(self.surface, self.text_outline_color, cursor_rect.inflate(2,2))
         pygame.draw.rect(self.surface, self.text_color, cursor_rect)
 
     def paint(self) -> None:
@@ -269,13 +293,13 @@ class TextInput(Label, InteractiveWidget):
         text_rect.__setattr__(alignment.value, pos)
 
         
-        if cursor_rect.right > area.right+self.scroll.x:
-            self.scroll.x=cursor_rect.right - area.right - cursor_rect.w*2 
-        elif cursor_rect.x < self.scroll.x+area.left:
-            self.scroll.x= cursor_rect.left - area.left
-        self.scroll.x = max(self.scroll.x,0)
+        # if cursor_rect.right > area.right+self.scroll.x:
+        #     self.scroll.x=cursor_rect.right - area.right
+        # elif cursor_rect.x < self.scroll.x+area.left:
+        #     self.scroll.x= cursor_rect.left - area.left
+        # self.scroll.x = max(self.scroll.x,0)
 
-        if cursor_rect.bottom > area.bottom + self.scroll.y:
+        if cursor_rect.bottom > self.scroll.y + area.bottom:
             self.scroll.y = cursor_rect.bottom - area.bottom
         elif cursor_rect.y < self.scroll.y + area.top:
             self.scroll.y = cursor_rect.top - area.top