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

batFramework/gui/shape.py

@@ -1,266 +1,86 @@
 import batFramework as bf
 from .widget import Widget
 import pygame
-from typing import Self, Iterable
-from math import ceil
 
 
 class Shape(Widget):
-    def __init__(self, size: tuple[float, float] = None, *args, **kwargs):
-        super().__init__(size=size, convert_alpha=True)
-        self.color = (0, 0, 0, 0)
-        self.border_radius: list[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)
-        self.relief = 0
-        self.shadow_color: tuple[int, int, int] | str = (0, 0, 0, 255)
-        self.draw_mode = bf.drawMode.SOLID
+    def __init__(self,width:float,height:float):
+        self._color = (0,0,0,0)
+        self._border_radius:list[int] = [0] 
+        self._outline : int = 0 
+        self._outline_color : tuple[int,int,int] | str = (0,0,0,0) 
+        super().__init__(convert_alpha = True)
+        self.set_size(width,height)
 
-    def get_padded_bottom(self) -> float:
-        return self.rect.bottom - self.padding[3] - self.relief
 
-    def get_padded_height(self) -> float:
-        return self.rect.h - self.padding[1] - self.padding[3] - self.relief
-
-    def get_padded_top(self) -> float:
-        return self.rect.y + self.relief
-
-    def get_padded_rect(self) -> pygame.FRect:
-        return pygame.FRect(
-            self.rect.x + self.padding[0],
-            self.rect.y + self.padding[1],
-            self.rect.w - self.padding[2] - self.padding[0],
-            self.rect.h - self.padding[1] - self.padding[3] - self.relief,
-        )
-
-    def set_shadow_color(self, color: tuple[int, int, int] | str) -> Self:
-        self.shadow_color = color
-        self.dirty_surface = True
-        return self
-
-    def set_relief(self, relief: int) -> Self:
-        if relief < 0:
-            return self
-        self.dirty_shape = self.relief != relief
-        self.relief = relief
-        return self
-
-    def set_texture(
-        self, surface: pygame.SurfaceType, subsize: tuple[int, int] | None = None
-    ) -> Self:
-        self.texture_surface = surface
-        if subsize is None:
-            subsize = (ceil(surface.get_width() / 3), ceil(surface.get_height() / 3))
-        self.texture_subsize = subsize
-        self.dirty_surface = True
-        return self
-
-    def set_draw_mode(self, mode: bf.drawMode) -> Self:
-        self.draw_mode = mode
-        self.dirty_surface = True
-        return self
-
-    def get_draw_mode(self) -> bf.drawMode:
-        return self.draw_mode
-
-    def has_alpha_color(self) -> bool:
-        return (pygame.Color(self.color).a != 255) or (
-            pygame.Color(self.outline_color).a != 255
-        )
-
-    def __str__(self) -> str:
+    def to_string_id(self)->str:
         return "Shape"
 
-    def set_color(self, color: tuple[int, int, int] | str) -> Self:
-        self.color = color
-        self.dirty_surface = True
+    def set_color(self,color:tuple[int,int,int]|str) -> "Frame":
+        self._color = color
+        self.build()
         return self
 
-    def set_outline_color(self, color: tuple[int, int, int] | str) -> Self:
-        self.outline_color = color
-        self.dirty_surface = True
+    def set_outline_color(self,color:tuple[int,int,int]|str) -> "Frame":
+        self._outline_color = color
+        self.build()
         return self
 
-    def set_border_radius(self, value: int | list[int]) -> Self:
-        if isinstance(value, int):
-            self.border_radius = [value]
+    def set_border_radius(self,value:int|list[int]) -> "Frame":
+        if isinstance(value,int):
+            self._border_radius = [value]
         else:
-            self.border_radius = value
-        self.dirty_surface = True
+            self._border_radius = value
+        self.build()
         return self
-
-    def set_outline_width(self, value: int) -> Self:
-        self.outline_width = value
-        self.dirty_surface = True
+        
+    def set_outline_width(self,value:int) -> "Frame":
+        self._outline = value
+        self.build()
         return self
-
-    def paint(self) -> None:
-        if self.draw_mode == bf.drawMode.TEXTURED:
-            self._paint_textured()
-            return
-        if self.border_radius == [0]:
-            self._paint_shape()
-            if self.outline_width:
-                self._paint_outline()
+        
+    def build(self)->None:
+        if self.surface.get_size() != self.get_size_int():
+            self.surface = pygame.Surface(self.get_size_int())
+            if self.convert_alpha :
+                self.surface = self.surface.convert_alpha()
+                self.surface.fill((0,0,0,0))
+            if self.parent :
+                self.parent.children_modified()
+        if self._border_radius == [0]:
+            self._build_shape()    
+            if self._outline : self._build_outline()
         else:
-            self._paint_rounded_shape()
-            if self.outline_width:
-                self._paint_rounded_outline()
-
-    def _paint_textured(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
-        if self.texture_surface is None:
-            return
-        w, h = self.surface.get_size()
-        sw, sh = self.texture_surface.get_size()
-        sub = self.texture_subsize
-
-        # center
-        center_surface = self.texture_surface.subsurface((sub[0], sub[1], *sub))
-        top_surface = self.texture_surface.subsurface((sub[0], 0, *sub))
-        bottom_surface = self.texture_surface.subsurface((sub[0], sh - sub[1], *sub))
-        left_surface = self.texture_surface.subsurface((0, sub[1], *sub))
-        right_surface = self.texture_surface.subsurface((sw - sub[0], sub[1], *sub))
+            self._build_rounded_shape()
+            if self._outline : self._build_rounded_outline()
 
-        lst = []
-        for y in range(sub[1], h + 1 - sub[1] * 2, sub[1]):
-            for x in range(sub[0], w + 1 - sub[0] * 2, sub[0]):
-                lst.append((center_surface, (x, y)))
 
-        w_remainder = w % sub[0]
-        h_remainder = h % sub[1]
-        fix_x = ((w // sub[0]) - 1) * sub[0]
-        fix_y = ((h // sub[1]) - 1) * sub[1]
+    def _build_shape(self)->None:
+        self.surface.fill(self._color)
 
-        if (w > sub[0]) and (w_remainder > 0):
-            # Center : Fix gaps on the x axis
-            h_portion = center_surface.subsurface(0, 0, w_remainder, sub[1])
-            for y in range(sub[1], h - sub[1] * 2, sub[1]):
-                lst.append((h_portion, (fix_x, y)))
-
-            # Fix partial gaps on the top
-
-            t_portion = top_surface.subsurface(0, 0, w_remainder, sub[1])
-            lst.append((t_portion, (fix_x, 0)))
-
-            # Fix partial gaps on the bottom
-            b_portion = bottom_surface.subsurface(0, 0, w_remainder, sub[1])
-            lst.append((b_portion, (fix_x, h - sub[1] - 1)))
-
-        if (h > sub[1]) and (h_remainder > 0):
-            # Center : Fix gaps on the y axis
-            v_portion = center_surface.subsurface(0, 0, sub[0], h_remainder)
-            for x in range(sub[0], w - sub[0] * 2, sub[0]):
-                lst.append((v_portion, (x, fix_y)))
-
-            # Fix partial gaps on the left
-            l_portion = left_surface.subsurface(0, 0, sub[0], h_remainder)
-            lst.append((l_portion, (0, fix_y)))
-
-            # Fix partial gaps on the right
-            r_portion = right_surface.subsurface(0, 0, sub[0], h_remainder)
-            lst.append((r_portion, (w - sub[0] - 1, fix_y)))
-
-        # fix corner gap
-        if h > sub[1] or w > sub[0]:
-            corner_portion = center_surface.subsurface(
-                0,
-                0,
-                w_remainder if w_remainder else sub[0],
-                h_remainder if h_remainder else sub[1],
-            )
-            if w_remainder == 0:
-                fix_x -= sub[0]
-            if h_remainder == 0:
-                fix_y -= sub[1]
-            lst.append((corner_portion, (fix_x - 1, fix_y - 1)))
-
-        # borders
-        lst.extend(
-            [(top_surface, (x, 0)) for x in range(sub[0], w + 1 - sub[0] * 2, sub[0])]
-            + [
-                (bottom_surface, (x, h - sub[1] - 1))
-                for x in range(sub[0], w + 1 - sub[0] * 2, sub[0])
-            ]
-            + [
-                (left_surface, (0, y))
-                for y in range(sub[1], h + 1 - sub[1] * 2, sub[1])
-            ]
-            + [
-                (right_surface, (w - sub[0] - 1, y))
-                for y in range(sub[1], h + 1 - sub[1] * 2, sub[1])
-            ]
-            + [
-                (self.texture_surface.subsurface((0, 0, *sub)), (0, 0)),
-                (
-                    self.texture_surface.subsurface((sw - sub[0], 0, *sub)),
-                    (w - sub[0] - 1, 0),
-                ),
-                (
-                    self.texture_surface.subsurface((0, sh - sub[1], *sub)),
-                    (0, h - sub[1] - 1),
-                ),
-                (
-                    self.texture_surface.subsurface((sw - sub[0], sh - sub[1], *sub)),
-                    (w - sub[0] - 1, h - sub[1] - 1),
-                ),
-            ]
+    def _build_rounded_shape(self)->None:
+        self.surface.fill((0,0,0,0))
+        pygame.draw.rect(
+            self.surface,
+            self._color,
+            (0,0,*self.rect.size),
+            0,
+            *self._border_radius
         )
 
-        self.surface.fblits(lst)
-
-    def _get_elevated_rect(self) -> pygame.FRect:
-        return pygame.FRect(0, 0, self.rect.w, self.rect.h - self.relief)
-
-    def _get_base_rect(self) -> pygame.FRect:
-        return pygame.FRect(0, self.rect.h - self.relief, self.rect.w, self.relief)
-
-    def _paint_shape(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
-        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()
-        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:
+    def _build_outline(self)->None:
         pygame.draw.rect(
             self.surface,
-            self.outline_color,
-            self._get_elevated_rect(),
-            self.outline_width,
+            self._outline_color,
+            (0,0,*self.rect.size),
+            self._outline
         )
-
-    def _paint_rounded_outline(self) -> None:
-        e = self._get_elevated_rect()
-        b = e.copy()
-        b.h += e.bottom - b.bottom
-
+    
+    def _build_rounded_outline(self)->None:
         pygame.draw.rect(
             self.surface,
-            self.outline_color,
-            e,
-            self.outline_width,
-            *self.border_radius,
+            self._outline_color,
+            (0,0,*self.rect.size),
+            self._outline,
+            *self._border_radius
         )
-        if self.relief:
-            pygame.draw.rect(
-                self.surface,
-                self.outline_color,
-                b,
-                self.outline_width,
-                *self.border_radius,
-            )

batFramework/gui/toggle.py

@@ -1,112 +1,62 @@
 from .button import Button
-from .indicator import Indicator, ToggleIndicator
+from .indicator import Indicator,ToggleIndicator
+import pygame
 import batFramework as bf
 from typing import Self
-import pygame
-
 
 class Toggle(Button):
-    def __init__(self, text: str = "", callback=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)
-        # self.set_gap(int(max(4, self.get_padded_width() / 3)))
-
-    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
+    def __init__(self,text:str,default_value : bool = False)->None:
+        self.value :bool= default_value
+        self.on_toggle = None
+        self.indicator : Indicator=ToggleIndicator(default_value)
+        self.gap :float|int = 0
+        super().__init__(text,self.toggle)
+        self.add_child(self.indicator)
+        self.set_gap(int(max(4,self.get_content_width()/3)))
+        # self.set_gap()
+        # self.set_gap(20)
+
+    def set_gap(self,value:int|float)->Self:
+        if value < 0 : return self
         self.gap = value
-        self.dirty_shape = True
+        self.build()
+        if self.parent : self.parent.children_modified()
         return self
-
-    def __str__(self) -> str:
+    def to_string_id(self)->str:
         return f"Toggle({self.value})"
+        
+    def toggle(self)->None:
+        self.value = not self.value
+        self.build()
+        if self.on_toggle : self.on_toggle(self.value)
+
+    def set_toggle_callback(self,callback)->Self:
+        self.on_toggle = callback
+        return self
 
-    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()
+    def _build_layout(self)->None:
+        self.indicator.set_value(self.value)
+        
         size = (
-            max(
-                self.indicator.get_min_required_size()[0],
-                self.text_rect.w + self.font_object.point_size + (self.gap if self.text else 0),
-            ),
-            self.text_rect.h,
-        )
-        return self.inflate_rect_by_padding((0, 0, *size)).size
-
-    def _build_layout(self) -> None:
-        gap = self.gap if self.text else 0
-        self.text_rect.size = self._get_text_rect_required_size()
-
-        #right part size
-        right_part_height = min(self.text_rect.h, self.font_object.point_size)
-        self.indicator.set_size_if_autoresize((right_part_height,right_part_height))
-
-        #join left and right
-        joined_rect = pygame.FRect(
-            0, 0, self.text_rect.w + gap + self.indicator.rect.w, self.text_rect.h 
+            0,
+            0,
+            self._text_rect.w + self.indicator.rect.w + self.gap,
+            max(self._text_rect.h, self.indicator.rect.h)
         )
-
-
-        if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding(joined_rect)
-            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
-
-        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)
-
-        self.align_text(joined_rect, padded_relative.move( offset), self.alignment)
-        self.text_rect.midleft = joined_rect.midleft
-
-        if self.text:
-            match self.spacing:
-                case bf.spacing.MAX:
-                    gap = padded_relative.right - self.text_rect.right - self.indicator.rect.w
-                case bf.spacing.MIN:
-                    gap = 0
-
-        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.indicator.rect.topleft = pos
+        
+        required_rect = self.inflate_rect_by_padding(size)
+        
+        if self.autoresize and (self.rect.size != required_rect.size) :
+            self.set_size(*required_rect.size)
+            return
+
+        required_rect = self.get_content_rect()
+        required_rect_rel = self.get_content_rect_rel()
+
+        self._text_rect.midleft = required_rect_rel.midleft
+        r = self.indicator.rect.copy()
+        r.midleft = required_rect.move(self._text_rect.w+self.gap,0).midleft
+        self.indicator.set_position(*r.topleft)
+        
+        self.surface.blit(self._text_surface,self._text_rect)
+