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

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()
@@ -181,6 +196,6 @@ class InteractiveWidget(Widget):
         pygame.draw.rect(
             camera.surface,
             "white",
-            self.rect.move(-camera.rect.x, -camera.rect.y).inflate(delta, delta),
+            self.rect.move(-camera.rect.x, -camera.rect.y),#.inflate(delta, delta),
             1,
         )

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
@@ -101,13 +101,20 @@ class Label(Shape):
         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()
+        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:
             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_surface = True
+        self.dirty_shape = True
         return self
 
     def set_text_outline_color(self, color) -> Self:
@@ -117,20 +124,20 @@ 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) -> "Label":
+    def set_alignment(self, alignment: bf.alignment) -> Self:
         self.alignment = alignment
         self.dirty_surface = True
         return self
 
-    def set_auto_wraplength(self, val: bool) -> "Label":
+    def set_auto_wraplength(self, val: bool) -> Self:
         self.auto_wraplength = val
         if self.autoresize_h or self.autoresize_w:
             self.dirty_shape = True
@@ -140,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:
@@ -186,20 +194,10 @@ class Label(Shape):
         if not (self.autoresize_w or self.autoresize_h):
             return self.rect.size
         if not self.text_rect:
-            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
-                ),
-            }
-
-            self.text_rect.size = self._render_font(params).get_size()
+            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
         )
@@ -242,19 +240,35 @@ class Label(Shape):
             surf = self.font_object.render(**params)
 
         return surf
+    def _get_text_rect_required_size(self):
+        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
 
     def _build_layout(self) -> None:
 
-        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,
-        }
+        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) 
 
-        self.text_rect.size = self._render_font(params).get_size()
         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:
@@ -265,9 +279,14 @@ 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]:
+        mask_size = self._text_outline_mask.get_size()
+        return  mask_size[0]//2,mask_size[1]//2
+
     def _paint_text(self) -> None:
         if self.font_object is None:
             print(f"No font for widget with text : '{self}' :(")
@@ -279,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:
@@ -291,15 +311,15 @@ class Label(Shape):
             )
 
         l = []
+        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(-1, self.relief - self.get_relief() - 1),
-                )
+                (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(0, self.relief - self.get_relief()))
+            (self.text_surface, self.text_rect)
         )
         self.surface.fblits(l)
 
@@ -313,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()

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/root.py

@@ -95,6 +95,8 @@ class Root(InteractiveWidget):
         return self
 
     def do_handle_event(self, event):
+        if not self.parent_scene.get_sharedVar("player_has_control"):
+            return
         if self.focused:
             if event.type == pygame.KEYDOWN:
                 if self.focused.on_key_down(event.key):
@@ -128,6 +130,8 @@ class Root(InteractiveWidget):
 
     def update(self, dt: float) -> None:
         super().update(dt)
+        if not self.parent_scene.get_sharedVar("player_has_control",True):
+            return
         old = self.hovered
         transposed = self.drawing_camera.screen_to_world(pygame.mouse.get_pos())
         self.hovered = self.top_at(*transposed) if self.top_at(*transposed) else None
@@ -139,8 +143,10 @@ class Root(InteractiveWidget):
         if self.hovered and isinstance(self.hovered, InteractiveWidget):
             self.hovered.on_enter()
 
-    def draw(self, camera: bf.Camera) -> int:
+    def draw(self, camera: bf.Camera) -> None:
         super().draw(camera)
+        if not self.parent_scene.get_sharedVar("player_has_control"):
+            return
         if (
             self.parent_scene
             and self.parent_scene.active

batFramework/gui/shape.py

@@ -10,7 +10,7 @@ class Shape(Widget):
         super().__init__(size=size, convert_alpha=True)
         self.color = (0, 0, 0, 0)
         self.border_radius: list[int] = [0]
-        self.outline: int = 0
+        self.outline_width: int = 0
         self.outline_color: tuple[int, int, int] | str = (0, 0, 0, 255)
         self.texture_surface = None
         self.texture_subsize = (0, 0)
@@ -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:
@@ -97,7 +92,7 @@ class Shape(Widget):
         return self
 
     def set_outline_width(self, value: int) -> Self:
-        self.outline = value
+        self.outline_width = value
         self.dirty_surface = True
         return self
 
@@ -107,11 +102,11 @@ class Shape(Widget):
             return
         if self.border_radius == [0]:
             self._paint_shape()
-            if self.outline:
+            if self.outline_width:
                 self._paint_outline()
         else:
             self._paint_rounded_shape()
-            if self.outline:
+            if self.outline_width:
                 self._paint_rounded_outline()
 
     def _paint_textured(self) -> None:
@@ -224,40 +219,29 @@ class Shape(Widget):
 
     def _paint_shape(self) -> None:
         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())
+        if self.relief!=0:
+            self.surface.fill(self.shadow_color, self._get_base_rect())
+            self.surface.fill(self.color, self._get_elevated_rect())
+        else:
+            self.surface.fill(self.color, self._get_elevated_rect())
 
     def _paint_rounded_shape(self) -> None:
         self.surface.fill((0, 0, 0, 0))
         e = self._get_elevated_rect()
-        b = e.copy()
-        b.bottom = self.rect.h
-        pygame.draw.rect(self.surface, self.shadow_color, b, 0, *self.border_radius)
-        pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
+        if self.relief != 0:
+            b = e.copy()
+            b.bottom = self.rect.h
+            pygame.draw.rect(self.surface, self.shadow_color, b, 0, *self.border_radius)
+            pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
+        else:
+            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,
-            )
         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.outline,
+            self._get_elevated_rect(),
+            self.outline_width,
         )
 
     def _paint_rounded_outline(self) -> None:
@@ -269,7 +253,7 @@ class Shape(Widget):
             self.surface,
             self.outline_color,
             e,
-            self.outline,
+            self.outline_width,
             *self.border_radius,
         )
         if self.relief:
@@ -277,6 +261,6 @@ class Shape(Widget):
                 self.surface,
                 self.outline_color,
                 b,
-                self.outline,
+                self.outline_width,
                 *self.border_radius,
             )