batframework 1.0.9a10__py3-none-any.whl → 1.0.9a12__py3-none-any.whl

batFramework/gui/textWidget.py

@@ -0,0 +1,308 @@
+from math import ceil
+import pygame
+from .widget import Widget
+import batFramework as bf
+from typing import Literal, Self,Union
+
+class TextWidget(Widget):
+    def __init__(self, text:str):
+        super().__init__()
+        self.text = text
+
+        # Allows scrolling the text
+        self.allow_scroll : bool = True
+
+        # Scroll variable
+        # TODO make scroll work
+        self.scroll :pygame.Vector2 = pygame.Vector2(0,0)
+
+        # Enable/Disable antialiasing
+        self.antialias: bool = bf.FontManager().DEFAULT_ANTIALIAS
+
+        self.text_size = bf.FontManager().DEFAULT_FONT_SIZE
+
+        self.auto_wraplength: bool = False
+
+        self.text_color: tuple[int, int, int] | str = "black"
+
+        self.text_bg_color : tuple[int,int,int]| str |  None = None
+
+
+        self.text_outline_color: tuple[int, int, int] | str = "gray50"
+
+        self._text_outline_mask = pygame.Mask((3, 3), fill=True)
+
+        self.line_alignment = pygame.FONT_LEFT
+        # font name (given when loaded by utils) to use for the text
+
+        self.font_name = None
+        # reference to the font object
+        self.font_object = None
+        # Rect containing the text of the label
+        self.show_text_outline: bool = False
+
+        self.is_italic: bool = False
+
+        self.is_bold: bool = False
+
+        self.is_underlined: bool = False
+
+        super().__init__()
+        self.set_debug_color("purple")
+        self.set_autoresize(True)
+        self.set_font(force=True)
+        self.set_convert_alpha(True)
+
+
+    def set_padding(self, value): # can't set padding
+        return self
+
+    def __str__(self) -> str:
+        return f"TextWidget({repr(self.text)})"
+    
+    def set_allow_scroll(self, value:bool)->Self:
+        if self.allow_scroll == value: return self
+        self.allow_scroll = value
+        self.dirty_surface = True
+        return self
+
+    def set_scroll(self,x=None,y=None)->Self:
+        x = x if x is not None else self.scroll.x
+        y = y if y is not None else self.scroll.y
+
+        self.scroll.update(x,y)
+        self.dirty_surface = True
+        return self
+
+    def scroll_by(self,x=0,y=0)->Self:
+        self.scroll += x,y
+        self.dirty_surface = True
+        return self
+
+    def set_text_color(self, color) -> Self:
+        self.text_color = color
+        self.dirty_surface = True
+        return self
+
+    def set_text_bg_color(self, color) -> Self:
+        self.text_bg_color = color
+        self.set_convert_alpha(color is None)
+        self.dirty_surface = True
+        return self
+
+
+    def top_at(self, x, y):
+        return None
+
+    def set_line_alignment(self, alignment: Union[Literal["left"], Literal["right"], Literal["center"]]) -> Self:
+        self.line_alignment = alignment
+        self.dirty_surface = True
+        return self
+
+    def set_italic(self, value: bool) -> Self:
+        if value == self.is_italic:
+            return self
+        self.is_italic = value
+        if self.autoresize_h or self.autoresize_w:
+            self.dirty_shape = True
+        else:
+            self.dirty_surface = True
+        return self
+
+    def set_bold(self, value: bool) -> Self:
+        if value == self.is_bold:
+            return self
+        self.is_bold = value
+        if self.autoresize_h or self.autoresize_w:
+            self.dirty_shape = True
+        else:
+            self.dirty_surface = True
+        return self
+
+    def set_underlined(self, value: bool) -> Self:
+        if value == self.is_underlined:
+            return self
+        self.is_underlined = value
+        self.dirty_surface = True
+        return self
+    
+    def set_text_outline_mask_size(self,size:tuple[int,int])->Self:
+        old_size = self._text_outline_mask.get_size()
+        min_w, min_h = min(old_size[0], size[0]), min(old_size[1], size[1])
+        m = [
+            [self._text_outline_mask.get_at((x, y)) for x in range(min_w)]
+            for y in range(min_h)
+        ]
+        self._text_outline_mask = pygame.Mask(size, fill=True)
+        self.set_text_outline_matrix(m)
+        return self
+
+    def set_text_outline_matrix(self, matrix: list[list[0 | 1]]) -> Self:
+        if matrix is None:
+            matrix = [[0 for _ in range(3)] for _ in range(3)]
+        for y in range(3):
+            for x in range(3):
+                self._text_outline_mask.set_at((x, y), matrix[2 - y][2 - x])
+        self.dirty_shape = True
+        return self
+
+    def set_text_outline_color(self, color) -> Self:
+        self.text_outline_color = color
+        self.dirty_surface = True
+        return self
+
+    def set_show_text_outline(self,value:bool) -> Self:
+        self.show_text_outline = value
+        self.dirty_shape = True
+        return self
+
+    def set_auto_wraplength(self, val: bool) -> Self:
+        self.auto_wraplength = val
+        if self.autoresize_h or self.autoresize_w:
+            self.dirty_shape = True
+        else:
+            self.dirty_surface = True
+        return self
+
+    def get_debug_outlines(self):
+        if self.visible:
+            yield from super().get_debug_outlines()
+
+    def set_font(self, font_name: str = None, force: bool = False) -> Self:
+        if font_name == self.font_name and not force:
+            return self
+        self.font_name = font_name
+        self.font_object = bf.FontManager().get_font(self.font_name, self.text_size)
+        if self.autoresize_h or self.autoresize_w:
+            self.dirty_shape = True
+        else:
+            self.dirty_surface = True
+        return self
+
+    def set_text_size(self, text_size: int) -> Self:
+        text_size = (text_size // 2) * 2
+        if text_size == self.text_size:
+            return self
+        self.text_size = text_size
+        self.font_object = bf.FontManager().get_font(self.font_name, self.text_size)
+        self.dirty_shape = True
+        return self
+
+    def get_text_size(self) -> int:
+        return self.text_size
+
+
+    def is_antialias(self) -> bool:
+        return self.antialias
+
+    def set_antialias(self, value: bool) -> Self:
+        self.antialias = value
+        self.dirty_surface = True
+        return self
+
+    def set_text(self, text: str) -> Self:
+        if text == self.text:
+            return self
+        self.text = text
+        self.dirty_shape = True
+        return self
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        if not self.font_object : return 0,0
+
+        tmp_text = self.text
+        if self.text.endswith('\n'):
+            tmp_text+=" " # hack to have correct size if ends with newline
+        params = {
+            "font_name": self.font_object.name,
+            "text": tmp_text,
+            "antialias": self.antialias,
+            "color": self.text_color,
+            "bgcolor": self.text_bg_color,
+            "wraplength": int(self.get_inner_width()) if self.auto_wraplength and not self.autoresize_w else 0,
+        }
+
+        size = list(self._render_font(params).get_size())
+        size[1]= max(size[1],self.font_object.get_ascent() - self.font_object.get_descent())
+        if not self.show_text_outline:
+            return size
+        s = self._get_outline_offset()
+        return size[0] + s[0]*2, size[1] + s[1]*2
+    
+
+    def get_text(self) -> str:
+        return self.text
+
+    def _render_font(self, params: dict) -> pygame.Surface:
+        params.pop("font_name")
+        # save old settings
+        old_italic = self.font_object.get_italic()
+        old_bold = self.font_object.get_bold()
+        old_underline = self.font_object.get_underline()
+        old_align = self.font_object.align
+        # setup font
+        self.font_object.set_italic(self.is_italic)
+        self.font_object.set_bold(self.is_bold)
+        self.font_object.set_underline(self.is_underlined)
+        self.font_object.align = self.line_alignment
+        surf = self.font_object.render(**params)
+        # reset font
+        self.font_object.set_italic(old_italic)
+        self.font_object.set_bold(old_bold)
+        self.font_object.set_underline(old_underline)
+        self.font_object.align = old_align
+        return surf
+
+    def _get_outline_offset(self)->tuple[int,int]:
+        mask_size = self._text_outline_mask.get_size()
+        return  mask_size[0]//2,mask_size[1]//2
+
+
+    def build(self) -> bool:
+        """
+        return True if size changed
+        """
+        target_size = self.resolve_size(self.get_min_required_size())
+        if self.rect.size != target_size:
+            self.set_size(target_size)
+            return True
+        return False
+        
+
+
+    def paint(self) -> None:
+        self._resize_surface()
+        if self.font_object is None:
+            print(f"No font for widget with text : '{self}' :(")
+            return
+        
+            
+        wrap = int(self.get_inner_width()) if self.auto_wraplength and not self.autoresize_w else 0
+        params = {
+            "font_name": self.font_object.name,
+            "text": self.text,
+            "antialias": self.antialias,
+            "color": self.text_color,
+            "bgcolor": self.text_bg_color if not self.show_text_outline else None,
+            "wraplength": wrap,
+        }
+
+        if self.text_bg_color is None : 
+            self.surface = self.surface.convert_alpha()
+
+        bg_fill_color = (0, 0, 0, 0) if self.text_bg_color is None else  self.text_bg_color 
+        self.surface.fill(bg_fill_color)
+
+        text_surf = self._render_font(params)
+
+        if self.show_text_outline:
+            mask = pygame.mask.from_surface(text_surf).convolve(self._text_outline_mask)
+            outline_surf = mask.to_surface(
+                setcolor=self.text_outline_color,
+                unsetcolor=bg_fill_color
+            )
+
+            outline_surf.blit(text_surf,self._get_outline_offset())
+            text_surf = outline_surf
+
+        self.surface.blit(text_surf, -self.scroll)

batFramework/gui/toggle.py

@@ -1,128 +1,140 @@
-from .button import Button
-from .indicator import Indicator, ToggleIndicator
-from .shape import Shape
-import batFramework as bf
-from typing import Self,Callable,Any
-
-class Toggle(Button):
-    def __init__(self, text: str = "", callback : Callable[[bool],Any]=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)
-
-    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.dirty_shape = True
-        return self
-
-    def __str__(self) -> str:
-        return f"Toggle({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()
-
-        text_width, text_height = self.text_rect.size
-        indicator_size = self.indicator.get_min_required_size()[1]
-        gap = self.gap if self.text else 0
-
-        total_width = text_width + gap + indicator_size
-        total_height = text_height + self.unpressed_relief
-
-        return self.expand_rect_with_padding((0, 0, total_width, total_height)).size
-
-    def _build_composed_layout(self,other:Shape):
-        size_changed = False
-        self.text_rect.size = self._get_text_rect_required_size()
-
-        gap = self.gap if self.text else 0
-        full_rect = self.text_rect.copy()
-
-        other_height = min(self.text_rect.h, self.font_object.get_height()+1)
-        other.set_size(other.resolve_size((other_height,other_height)))
-        
-        full_rect.w += other.rect.w + gap
-        full_rect.h += self.unpressed_relief
-        
-
-        # take into account the relief when calculating target size
-        inflated = self.expand_rect_with_padding((0, 0, *full_rect.size)).size
-        target_size = self.resolve_size(inflated)
-        if self.rect.size != target_size:
-            self.set_size(target_size)
-            size_changed = True
-
-        self._align_composed(other)
-        return size_changed
-
-    def _align_composed(self,other:Shape):
-        
-        full_rect = self.get_local_inner_rect()
-        left_rect = self.text_rect
-        right_rect = other.rect
-        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
-
-        if self.alignment in {bf.alignment.TOP, bf.alignment.TOPLEFT, bf.alignment.TOPRIGHT}:
-            left_rect.top = right_rect.top = full_rect.top
-        elif self.alignment in {bf.alignment.BOTTOM, bf.alignment.BOTTOMLEFT, bf.alignment.BOTTOMRIGHT}:
-            left_rect.bottom = right_rect.bottom = full_rect.bottom
-        else:
-            left_rect.centery = right_rect.centery = full_rect.centery
-
-        right_rect.move_ip(*self.rect.topleft)
-
-    def _build_layout(self) -> None:
-        return self._build_composed_layout(self.indicator)
-
-
-
+from .widget import Widget
+from .button import Button
+from .indicator import Indicator, ToggleIndicator
+from .shape import Shape
+import batFramework as bf
+from typing import Self, Callable, Any
+import pygame
+from .syncedVar import SyncedVar  # Adjust import path
+
+class Toggle(Button):
+    def __init__(
+        self,
+        text: str = "",
+        callback: Callable[[bool], Any] = None,
+        default_value: bool = False,
+        synced_var: SyncedVar[bool] = None,
+    ) -> None:
+        # Use passed SyncedVar or create a new one
+        self.synced_var: SyncedVar[bool] = synced_var or SyncedVar(default_value)
+
+        # Local value synced to SyncedVar.value
+        self.value: bool = self.synced_var.value
+
+        self.indicator: ToggleIndicator = ToggleIndicator(self.value)
+        self.gap: float | int = 0
+        self.spacing: bf.spacing = bf.spacing.MANUAL
+
+        super().__init__(text, callback)
+
+        # Add indicator to widget
+        self.add(self.indicator)
+        self.set_clip_children(False)
+
+        # Bind this toggle’s _on_synced_var_update to synced_var updates
+        self.synced_var.bind(self, self._on_synced_var_update)
+
+    def _on_synced_var_update(self, new_value: bool) -> None:
+        # Called when SyncedVar changes externally
+        if self.value != new_value:
+            self.set_value(new_value, do_callback=False)
+
+
+    def set_indicator(self,indicator:Indicator):
+        self.remove(self.indicator)
+        self.synced_var.unbind(self.indicator)
+        self.indicator = indicator
+        self.add(self.indicator)
+    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:
+        if self.value == value:
+            return self  # No change
+
+        self.value = value
+        self.indicator.set_value(value)
+        self.dirty_surface = True
+
+        # Update SyncedVar only if different (avoid recursion)
+        if self.synced_var.value != value:
+            self.synced_var.value = value
+
+        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, do_callback=True)
+
+    def set_gap(self, value: int | float) -> Self:
+        value = max(0, value)
+        if value == self.gap:
+            return self
+        self.gap = value
+        self.dirty_shape = True
+        return self
+
+    def __str__(self) -> str:
+        return f"Toggle({self.value})"
+
+    def toggle(self) -> None:
+        self.set_value(not self.value, do_callback=True)
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        left = self.text_widget.get_min_required_size()
+        gap = self.gap if self.text_widget.text else 0
+        full_rect = pygame.FRect(0, 0, left[0] + left[1] + gap, left[1])
+        full_rect.h += self.unpressed_relief
+        return self.expand_rect_with_padding((0, 0, *full_rect.size)).size
+
+    def _align_composed(self, left: Shape, right: Shape):
+        full_rect = self.get_inner_rect()
+        left_rect = left.rect
+        right_rect = right.rect
+        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)
+
+        # Set horizontal positions
+        left.set_position(x=group_x)
+        right.set_position(x=group_x + left_rect.width + gap)
+
+        # Set vertical positions
+        if self.alignment in {bf.alignment.TOP, bf.alignment.TOPLEFT, bf.alignment.TOPRIGHT}:
+            left.set_position(y=full_rect.top)
+            right.set_position(y=full_rect.top)
+        elif self.alignment in {bf.alignment.BOTTOM, bf.alignment.BOTTOMLEFT, bf.alignment.BOTTOMRIGHT}:
+            left.set_position(y=full_rect.bottom - left_rect.height)
+            right.set_position(y=full_rect.bottom - right_rect.height)
+        else:
+            left.set_center(y=full_rect.centery)
+            right.set_center(y=full_rect.centery)
+
+    def build(self) -> None:
+        res = super().build()
+        self.indicator.set_size(self.indicator.resolve_size((self.text_widget.rect.h, self.text_widget.rect.h)))
+        self._align_composed(self.text_widget, self.indicator)
+        return res

batFramework/gui/tooltip.py

@@ -1,30 +1,35 @@
-from .label import Label
-import batFramework as bf
-import sys
-
-class ToolTip(Label):
-    def __init__(self, text = ""):
-        super().__init__(text)
-        self.fade_in_duration : float = 0.1
-        self.fade_out_duration : float = 0.1
-        self.set_render_order(sys.maxsize)
-    
-    def __str__(self):
-        return f"ToolTip('{self.text}')"
-
-    def top_at(self, x, y):
-        return None
-
-    def fade_in(self):
-        self.set_visible(True)
-        bf.PropertyEaser(
-            self.fade_in_duration,bf.easing.EASE_OUT,
-            0,self.parent_scene.name
-        ).add_custom(self.get_alpha,self.set_alpha,255).start()
-
-    def fade_out(self):
-        bf.PropertyEaser(
-            self.fade_out_duration,bf.easing.EASE_IN,
-            0,self.parent_scene.name,
-            lambda : self.set_visible(False)
-        ).add_custom(self.get_alpha,self.set_alpha,0).start()
+from .label import Label
+import batFramework as bf
+import sys
+
+class ToolTip(Label):
+    def __init__(self, text = ""):
+        super().__init__(text)
+        self.fade_in_duration : float = 0.1
+        self.fade_out_duration : float = 0.1
+        self.set_render_order(sys.maxsize)
+        self.set_padding(2)
+    
+    def __str__(self):
+        return f"ToolTip('{self.text_widget.text}')"
+
+    def top_at(self, x, y):
+        return None
+
+    def set_all_alpha(self,value:int):
+        self.text_widget.set_alpha(value)
+        return self.set_alpha(value)
+
+    def fade_in(self):
+        self.set_visible(True)
+        bf.PropertyEaser(
+            self.fade_in_duration,bf.easing.EASE_OUT,
+            0,self.parent_scene.name
+        ).add_custom(self.get_alpha,self.set_all_alpha,255).start()
+
+    def fade_out(self):
+        bf.PropertyEaser(
+            self.fade_out_duration,bf.easing.EASE_IN,
+            0,self.parent_scene.name,
+            lambda : self.set_visible(False)
+        ).add_custom(self.get_alpha,self.set_all_alpha,0).start()