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

batFramework/gui/constraints/constraints.py

@@ -4,9 +4,12 @@ import pygame
 
 
 class Constraint:
-    def __init__(self, name="Constraint", priority=0):
+    def __init__(self, name:str|None=None, priority=0):
         self.priority = priority
-        self.name = name
+        self.name = name if name is not None else self.__class__.__name__
+
+    def on_removal(self,child_widget: Widget)->None:
+        pass
 
     def set_priority(self, priority) -> "Constraint":
         self.priority = priority
@@ -34,13 +37,20 @@ class Constraint:
 
 class MinWidth(Constraint):
     def __init__(self, width: float):
-        super().__init__(name="min_width")
+        super().__init__()
         self.min_width = width
 
+    def on_removal(self, child_widget: Widget) -> None:
+            child_widget.set_autoresize_w(False)
+
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width >= self.min_width
+        res =  child_widget.rect.width >= self.min_width
+        if not res:
+            child_widget.set_autoresize_w(False)
+        return res
 
     def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_w(True)
         child_widget.set_size((self.min_width, None))
 
     def __eq__(self,other:"Constraint")->bool:
@@ -53,11 +63,17 @@ class MinWidth(Constraint):
 
 class MinHeight(Constraint):
     def __init__(self, height: float):
-        super().__init__(name="min_height")
+        super().__init__()
         self.min_height = height
 
+    def on_removal(self, child_widget: Widget) -> None:
+            child_widget.set_autoresize_h(False)
+
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.h >= self.min_height
+        res = child_widget.rect.h >= self.min_height
+        if not res:
+            child_widget.set_autoresize_w(False)
+        return res
 
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_size((None, self.min_height))
@@ -70,9 +86,60 @@ class MinHeight(Constraint):
             other.min_height == self.min_height
         )
 
+class MaxWidth(Constraint):
+    def __init__(self, width: float):
+        super().__init__()
+        self.max_width = width
+
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize_w(False)
+
+    def evaluate(self, parent_widget, child_widget):
+        res = child_widget.rect.width <= self.max_width
+        if not res:
+            child_widget.set_autoresize_w(False)
+        return res
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_w(True)
+        current_height = child_widget.rect.height
+        child_widget.set_size((self.max_width, current_height))
+
+    def __eq__(self, other: "Constraint") -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return other.max_width == self.max_width
+
+
+class MaxHeight(Constraint):
+    def __init__(self, height: float):
+        super().__init__()
+        self.max_height = height
+
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize_h(False)
+
+    def evaluate(self, parent_widget, child_widget):
+        res = child_widget.rect.height <= self.max_height
+        if not res:
+            child_widget.set_autoresize_h(False)
+        return res
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_autoresize_h(True)
+        current_width = child_widget.rect.width
+        child_widget.set_size((current_width, self.max_height))
+
+    def __eq__(self, other: "Constraint") -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return other.max_height == self.max_height
+
+
+
 class CenterX(Constraint):
     def __init__(self):
-        super().__init__(name="centerx")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -87,7 +154,7 @@ class CenterX(Constraint):
 
 class CenterY(Constraint):
     def __init__(self):
-        super().__init__(name="centery")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -102,7 +169,7 @@ class CenterY(Constraint):
 
 class Center(Constraint):
     def __init__(self):
-        super().__init__(name="center")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -117,10 +184,13 @@ class Center(Constraint):
 
 class PercentageWidth(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_width")
+        super().__init__()
         self.percentage: float = percentage
         self.keep_autoresize: bool = keep_autoresize
 
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize_w(True)
+
     def __str__(self) -> str:
         return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
 
@@ -153,10 +223,13 @@ class PercentageWidth(Constraint):
 
 class PercentageHeight(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_height")
+        super().__init__()
         self.percentage: float = percentage
         self.keep_autoresize: bool = keep_autoresize
 
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize_h(True)
+
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.height == round(
             parent_widget.get_padded_height() * self.percentage
@@ -188,7 +261,7 @@ class PercentageHeight(Constraint):
 class FillX(PercentageWidth):
     def __init__(self, keep_autoresize: bool = False):
         super().__init__(1, keep_autoresize)
-        self.name = "fill_x"
+        self.name = "FillX"
 
     def __eq__(self, other: Constraint) -> bool:
         return Constraint.__eq__(self,other)
@@ -196,7 +269,7 @@ class FillX(PercentageWidth):
 class FillY(PercentageHeight):
     def __init__(self, keep_autoresize: bool = False):
         super().__init__(1, keep_autoresize)
-        self.name = "fill_y"
+        self.name = "FillY"
 
     def __eq__(self, other: Constraint) -> bool:
         return Constraint.__eq__(self,other)
@@ -204,10 +277,13 @@ class FillY(PercentageHeight):
 
 class PercentageRectHeight(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_rect_height")
+        super().__init__()
         self.percentage: float = percentage
         self.keep_autoresize: bool = keep_autoresize
 
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize_h(True)
+
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.height == round(
             parent_widget.rect.height * self.percentage
@@ -238,10 +314,13 @@ class PercentageRectHeight(Constraint):
 
 class PercentageRectWidth(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_rect_width")
+        super().__init__()
         self.percentage: float = percentage
         self.keep_autoresize: bool = keep_autoresize
 
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize_w(True)
+
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.width == round(
             parent_widget.rect.width * self.percentage
@@ -287,7 +366,7 @@ class AspectRatio(Constraint):
         reference_axis: bf.axis = bf.axis.HORIZONTAL,
         keep_autoresize=False,
     ):
-        super().__init__(name="aspect_ratio")
+        super().__init__()
         self.ref_axis: bf.axis = reference_axis
         self.keep_autoresize: bool = keep_autoresize
 
@@ -302,6 +381,10 @@ class AspectRatio(Constraint):
         else:
             raise TypeError(f"Ratio must be float or FRect")
 
+    def on_removal(self, child_widget: Widget) -> None:
+        child_widget.set_autoresize(True)
+
+
     def evaluate(self, parent_widget, child_widget):
         if self.ref_axis == bf.axis.HORIZONTAL:
             return self.ratio == child_widget.rect.h / child_widget.rect.w
@@ -343,7 +426,7 @@ class AspectRatio(Constraint):
 
 class AnchorBottom(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_bottom")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -358,7 +441,7 @@ class AnchorBottom(Constraint):
 
 class AnchorTop(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_top")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (child_widget.rect.top == parent_widget.get_padded_top())
@@ -369,21 +452,21 @@ class AnchorTop(Constraint):
 
 class AnchorTopRight(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_topright")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.topright == parent_widget.get_padded_rect().topright
 
     def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            parent_widget.get_padded_top(),
-        )
+        # print("before",child_widget.rect.topright, parent_widget.get_padded_rect().topright)
+        topright = parent_widget.get_padded_rect().topright
+        child_widget.set_position(topright[0] - child_widget.rect.w,topright[1])
+        # print("after",child_widget.rect.topright, parent_widget.get_padded_rect().topright)
 
 
 class AnchorBottomRight(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_bottomright")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return (
@@ -391,15 +474,17 @@ class AnchorBottomRight(Constraint):
         )
 
     def apply_constraint(self, parent_widget, child_widget):
+        bottomright =  parent_widget.get_padded_rect().bottomright
+
         child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            parent_widget.get_padded_bottom() - child_widget.rect.h,
+            bottomright[0] - child_widget.rect.w,
+            bottomright[1] - child_widget.rect.h,
         )
 
 
 class AnchorRight(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_right")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.right == parent_widget.get_padded_right()
@@ -413,7 +498,7 @@ class AnchorRight(Constraint):
 
 class AnchorLeft(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_left")
+        super().__init__()
 
     def evaluate(self, parent_widget, child_widget):
         return child_widget.rect.left == parent_widget.get_padded_left()
@@ -426,7 +511,7 @@ class AnchorLeft(Constraint):
 
 class MarginBottom(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_bottom")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -450,7 +535,7 @@ class MarginBottom(Constraint):
 
 class MarginTop(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_top")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -471,7 +556,7 @@ class MarginTop(Constraint):
 
 class MarginLeft(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_left")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -493,7 +578,7 @@ class MarginLeft(Constraint):
 
 class MarginRight(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="margin_right")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -515,7 +600,7 @@ class MarginRight(Constraint):
 
 class PercentageMarginBottom(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_bottom")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -543,7 +628,7 @@ class PercentageMarginBottom(Constraint):
 
 class PercentageMarginTop(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_top")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -570,7 +655,7 @@ class PercentageMarginTop(Constraint):
 
 class PercentageMarginLeft(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_left")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -598,7 +683,7 @@ class PercentageMarginLeft(Constraint):
 
 class PercentageMarginRight(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_margin_right")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -626,7 +711,7 @@ class PercentageMarginRight(Constraint):
 
 class PercentageRectMarginBottom(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_bottom")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -653,7 +738,7 @@ class PercentageRectMarginBottom(Constraint):
 
 class PercentageRectMarginTop(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_top")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -678,7 +763,7 @@ class PercentageRectMarginTop(Constraint):
 
 class PercentageRectMarginLeft(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_left")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):
@@ -704,7 +789,7 @@ class PercentageRectMarginLeft(Constraint):
 
 class PercentageRectMarginRight(Constraint):
     def __init__(self, margin: float):
-        super().__init__(name="percentage_rect_margin_right")
+        super().__init__()
         self.margin = margin
 
     def evaluate(self, parent_widget, child_widget):

batFramework/gui/image.py

@@ -21,15 +21,22 @@ class Image(Shape):
 
     def paint(self) -> None:
         super().paint()
-        # self.surface.fill((0,0,0,0 if self.convert_alpha else 255))
         if self.original_surface is None:
             return
-        if self.rect.size != self.original_surface.get_size():
-            self.surface.blit(
-                pygame.transform.scale(self.original_surface, self.rect.size), (0, 0)
-            )
+        padded = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
+        target_size = padded.size
+        if self.original_surface.get_size() != target_size:
+            self.surface.blit(pygame.transform.scale(self.original_surface, target_size), padded.topleft)
         else:
-            self.surface.blit(self.original_surface, (0, 0))
+            self.surface.blit(self.original_surface, padded.topleft)
+
+    def build(self) -> None:
+        if self.original_surface is not None:
+            self.set_size_if_autoresize(
+                self.inflate_rect_by_padding((0,0,*self.original_surface.get_size())).size
+            )
+        super().build()
+
 
     def from_path(self, path: str) -> Self:
         tmp = bf.ResourceManager().get_image(path, self.convert_alpha)
@@ -37,10 +44,6 @@ class Image(Shape):
             return self
         self.original_surface = tmp
         size = self.original_surface.get_size()
-        if not self.autoresize_h:
-            size[0] = None
-        if not self.autoresize_h:
-            size[1] = None
         self.set_size(size)
         self.dirty_surface = True
         return self
@@ -50,10 +53,7 @@ class Image(Shape):
             return self
         self.original_surface = surface
         size = self.original_surface.get_size()
-        if not self.autoresize_h:
-            size[0] = None
-        if not self.autoresize_h:
-            size[1] = None
         self.set_size(size)
+
         self.dirty_surface = True
         return self

batFramework/gui/interactiveWidget.py

@@ -8,6 +8,14 @@ if TYPE_CHECKING:
     from .container import Container
 import batFramework as bf
 
+def children_has_focus(widget):
+    if isinstance(widget,InteractiveWidget) and widget.is_focused:
+        return True
+    for child in widget.children:
+        if children_has_focus(child):
+            return True
+    return False
+
 
 class InteractiveWidget(Widget):
     def __init__(self, *args, **kwargs) -> None:
@@ -39,6 +47,13 @@ class InteractiveWidget(Widget):
             return True
         return False
 
+    def set_parent(self, parent: Widget) -> Self:
+        if parent is None and children_has_focus(self):
+            self.get_root().clear_focused()
+            # pass focus on
+
+        return super().set_parent(parent)
+
     def on_get_focus(self) -> None:
         self.is_focused = True
         self.do_on_get_focus()

batFramework/gui/label.py

@@ -2,7 +2,7 @@ import batFramework as bf
 import pygame
 from .shape import Shape
 from typing import Self
-
+from math import ceil
 
 class Label(Shape):
     _text_cache = {}
@@ -59,7 +59,7 @@ class Label(Shape):
         Label._text_cache = {}
 
     def __str__(self) -> str:
-        return f"Label({self.text})"
+        return f"Label({repr(self.text)})"
 
     def enable_caching(self) -> Self:
         self.do_caching = True
@@ -106,6 +106,7 @@ class Label(Shape):
         m = [[self._text_outline_mask.get_at((x,y)) for x in range(min(old_size[0],size[0]))] for y in range(min(old_size[1],size[1]))]
         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:
@@ -113,7 +114,7 @@ class Label(Shape):
         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_surface = True
+        self.dirty_shape = True
         return self
 
     def set_text_outline_color(self, color) -> Self:
@@ -123,12 +124,12 @@ class Label(Shape):
 
     def enable_text_outline(self) -> Self:
         self.show_text_outline = True
-        self.dirty_surface = True
+        self.dirty_shape = True
         return self
 
     def disable_text_outline(self) -> Self:
         self.show_text_outline = False
-        self.dirty_surface = True
+        self.dirty_shape = True
         return self
 
     def set_alignment(self, alignment: bf.alignment) -> Self:
@@ -146,7 +147,8 @@ class Label(Shape):
 
     def get_debug_outlines(self):
         if self.visible:
-            yield (self.text_rect.move(*self.rect.topleft), "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.rect.y - offset[1]), "purple")
         yield from super().get_debug_outlines()
 
     def set_font(self, font_name: str = None, force: bool = False) -> Self:
@@ -194,7 +196,8 @@ class Label(Shape):
         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
+
+        return res
         return res[0] if self.autoresize_w else self.rect.w, (
             res[1] if self.autoresize_h else self.rect.h
         )
@@ -238,22 +241,34 @@ class Label(Shape):
 
         return surf
     def _get_text_rect_required_size(self):
-        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,
-        }
+        font_height = self.font_object.get_linesize()
+        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
+            if self.text.endswith('\n'):
+                tmp_text+=" "
+            params = {
+                "font_name": self.font_object.name,
+                "text": tmp_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,
+            }
+
+            size = self._render_font(params).get_size()
+            size = size[0],max(font_height,size[1])
+        s = self._get_outline_offset() if self.show_text_outline else (0,0)
+        return size[0] + s[0]*2, size[1] + s[1]*2
 
-        size = self._render_font(params).get_size()
-        s = self._text_outline_mask.get_size()
-        return size[0] + s[0]//2, size[1] + s[1]//2
     def _build_layout(self) -> None:
 
         self.text_rect.size = self._get_text_rect_required_size()
-        
+        # self.text_rect.w = ceil(self.text_rect.w)
+        # self.text_rect.h = ceil(self.text_rect.h) 
+
         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:
@@ -264,7 +279,8 @@ class Label(Shape):
                 self.set_size(target_rect.size)
                 self.build()
                 return
-        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
+        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.align_text(self.text_rect, padded, self.alignment)
 
     def _get_outline_offset(self)->tuple[int,int]:
@@ -282,8 +298,9 @@ 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 else 0,
+            "wraplength": int(self.get_padded_width()) if self.auto_wraplength and not self.autoresize_w else 0,
         }
+
         self.text_surface = self._render_font(params)
 
         if self.show_text_outline:
@@ -294,16 +311,15 @@ class Label(Shape):
             )
 
         l = []
-        outline_offset = self._get_outline_offset()
+        outline_offset = self._get_outline_offset() if self.show_text_outline else (0,0)
+
         if self.show_text_outline:
             l.append(
-                (
-                    self.text_outline_surface,
-                    self.text_rect.move(0, self.relief - self.get_relief()),
-                )
+                (self.text_outline_surface,
+                (self.text_rect.x - outline_offset[0],self.text_rect.y - outline_offset[1]))
             )
         l.append(
-            (self.text_surface, self.text_rect.move(outline_offset[0], self.relief - self.get_relief() + outline_offset[1]))
+            (self.text_surface, self.text_rect)
         )
         self.surface.fblits(l)
 
@@ -317,6 +333,7 @@ class Label(Shape):
 
         pos = area.__getattribute__(alignment.value)
         text_rect.__setattr__(alignment.value, pos)
+        text_rect.y = ceil(text_rect.y)
 
     def build(self) -> None:
         super().build()