batframework 1.0.9a6__py3-none-any.whl → 1.0.9a8__py3-none-any.whl

batFramework/gui/label.py

@@ -1,7 +1,7 @@
 import batFramework as bf
 import pygame
 from .shape import Shape
-from typing import Self
+from typing import Literal, Self,Union
 from math import ceil
 
 class Label(Shape):
@@ -10,6 +10,10 @@ class Label(Shape):
     def __init__(self, text: str = "") -> None:
         self.text = text
 
+        # Allows scrolling the text
+        self.allow_scroll : bool = True
+
+        # Scroll variable
         self.scroll :pygame.Vector2 = pygame.Vector2(0,0)
 
         self.resized_flag: bool = False
@@ -31,6 +35,7 @@ class Label(Shape):
 
         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
@@ -59,11 +64,23 @@ class Label(Shape):
     def __str__(self) -> str:
         return f"Label({repr(self.text)})"
 
+
+    def set_allow_scroll(self, value:bool)->Self:
+        if self.allow_scroll == value: return self
+        self.allow_scroll = value
+        self.dirty_shape = True
+        return self
+
     def set_text_color(self, color) -> Self:
         self.text_color = color
         self.dirty_surface = True
         return self
 
+    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
@@ -136,10 +153,12 @@ class Label(Shape):
         return self
 
     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()
+        if self.visible:
+            yield (self.text_rect.move(self.rect.x - self.scroll.x,self.rect.y - self.scroll.y), "purple")
+            
+            # 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")
 
     def set_font(self, font_name: str = None, force: bool = False) -> Self:
         if font_name == self.font_name and not force:
@@ -153,13 +172,12 @@ class Label(Shape):
         return self
 
     def set_text_size(self, text_size: int) -> Self:
-        text_size = round(text_size / 2) * 2
+        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)
-        if self.autoresize_h or self.autoresize_w:
-            self.dirty_shape = True
+        self.dirty_shape = True
         return self
 
     def get_text_size(self) -> int:
@@ -181,15 +199,9 @@ class Label(Shape):
         return self
 
     def get_min_required_size(self) -> tuple[float, float]:
-        if not (self.autoresize_w or self.autoresize_h):
-            return self.rect.size
-        if not self.text_rect:
-            self.text_rect.size = self._get_text_rect_required_size()
-        res = self.inflate_rect_by_padding((0, 0, *self.text_rect.size)).size
-        
-        return res[0] if self.autoresize_w else self.rect.w, (
-            res[1] if self.autoresize_h else self.rect.h
-        )
+        return self.expand_rect_with_padding(
+            (0, 0, *self._get_text_rect_required_size())
+        ).size
 
     def get_text(self) -> str:
         return self.text
@@ -203,28 +215,32 @@ class Label(Shape):
             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
         else:
             params.pop("font_name")
             surf = self.font_object.render(**params)
 
         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 _get_text_rect_required_size(self):
-        font_height = self.font_object.get_linesize()
+        font_height = self.font_object.get_ascent() - self.font_object.get_descent()
         if not self.text:
-            # font_height = self.font_object.get_ascent() - self.font_object.get_ascent()
             size = (0,font_height)
         else:
             tmp_text = self.text
@@ -236,49 +252,43 @@ class Label(Shape):
                 "antialias": self.antialias,
                 "color": self.text_color,
                 "bgcolor": None,  # 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 and not self.autoresize_w else 0,
+                "wraplength": int(self.get_inner_width()) if self.auto_wraplength and not self.autoresize_w else 0,
             }
 
             size = self._render_font(params).get_size()
             size = size[0],max(font_height,size[1])
+            
+        # print(self.text,size)
         s = self._get_outline_offset() if self.show_text_outline else (0,0)
         return size[0] + s[0]*2, size[1] + s[1]*2
 
-    def _build_layout(self) -> None:
+    def _build_layout(self) -> bool:
+        ret = False
+        target_size = self.resolve_size(self.get_min_required_size())
 
-        # print(self.text_rect.size,self._get_text_rect_required_size(),repr(self.text))
-        self.text_rect.size = self._get_text_rect_required_size()
+        if self.rect.size != target_size :
+            self.set_size(target_size)
+            ret = True
+            # self.apply_post_updates(skip_draw=True)
+            # return True
 
-        if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding((0, 0, *self.text_rect.size))
-            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:
-                # print("Size not good ! ",self.rect.size,target_rect.size,repr(self.text))
-                self.set_size(target_rect.size)
-                self.apply_updates()
-
-        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])
+        self.text_rect.size = self._get_text_rect_required_size()
+        padded = self.get_local_padded_rect()
         self.align_text(self.text_rect, padded, self.alignment)
-
-    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
+        return ret
 
     def _paint_text(self) -> None:
         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": None,  # 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 and not self.autoresize_w else 0,
+            "bgcolor": None, 
+            "wraplength": wrap,
         }
 
         self.text_surface = self._render_font(params)
@@ -289,27 +299,22 @@ class Label(Shape):
                 .to_surface(setcolor=self.text_outline_color, unsetcolor=(0, 0, 0, 0))
             )
 
-        outline_offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-
-
-        # prepare fblit list
-        l = []
-        if self.show_text_outline:
-            l.append(
-                (self.text_outline_surface,
-                (self.text_rect.x - outline_offset[0] - self.scroll.x,self.text_rect.y - outline_offset[1] - self.scroll.y))
-            )
-        l.append(
-            (self.text_surface, self.text_rect.move(-self.scroll))
-        )
+            outline_offset = list(self._get_outline_offset())
+            outline_offset[0]-=self.scroll.x
+            outline_offset[1]-=self.scroll.y
+            l = [
+                (self.text_outline_surface,(self.text_rect.x  - self.scroll.x,self.text_rect.y - self.scroll.y)),
+                (self.text_surface, self.text_rect.move(*outline_offset))
+            ]
+        else:
+            l = [(self.text_surface, self.text_rect.move(-self.scroll))]        
 
         # clip surface
         
         old = self.surface.get_clip()
-        self.surface.set_clip(self.get_padded_rect().move(-self.rect.x,-self.rect.y))
+        self.surface.set_clip(self.get_local_padded_rect())
         self.surface.fblits(l)
         self.surface.set_clip(old)
-
         
     def align_text(
         self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
@@ -323,11 +328,16 @@ class Label(Shape):
         text_rect.__setattr__(alignment.value, pos)
         text_rect.y = ceil(text_rect.y)
 
-
-
-    def build(self) -> None:
+    def build(self) -> bool:
+        """
+        return True if size changed
+        """
+        
+        size_changed = self._build_layout()
         super().build()
-        self._build_layout()
+        return size_changed
+        
+        
 
     def paint(self) -> None:
         super().paint()