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

batFramework/gui/shape.py

@@ -1,86 +1,288 @@
 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,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 __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 get_padded_bottom(self) -> float:
+        return self.rect.bottom - self.padding[3] - self.relief
 
-    def to_string_id(self)->str:
+    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
+        if self.relief == relief:
+            return self
+        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:
+        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:
         return "Shape"
 
-    def set_color(self,color:tuple[int,int,int]|str) -> "Frame":
-        self._color = color
-        self.build()
+    def set_color(self, color: tuple[int, int, int] | str) -> Self:
+        self.color = color
+        self.dirty_surface = True
         return self
 
-    def set_outline_color(self,color:tuple[int,int,int]|str) -> "Frame":
-        self._outline_color = color
-        self.build()
+    def set_outline_color(self, color: tuple[int, int, int] | str) -> Self:
+        self.outline_color = color
+        self.dirty_surface = True
         return self
 
-    def set_border_radius(self,value:int|list[int]) -> "Frame":
-        if isinstance(value,int):
-            self._border_radius = [value]
+    def set_border_radius(self, value: int | list[int]) -> Self:
+        if isinstance(value, int):
+            self.border_radius = [value]
         else:
-            self._border_radius = value
-        self.build()
+            self.border_radius = value
+        self.dirty_surface = True
         return self
-        
-    def set_outline_width(self,value:int) -> "Frame":
-        self._outline = value
-        self.build()
+
+    def set_outline_width(self, value: int) -> Self:
+        self.outline_width = value
+        self.dirty_surface = True
         return self
-        
-    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()
+
+    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()
         else:
-            self._build_rounded_shape()
-            if self._outline : self._build_rounded_outline()
+            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
 
-    def _build_shape(self)->None:
-        self.surface.fill(self._color)
+        # 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))
 
-    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
+        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]
+
+        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_outline(self)->None:
+        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:
+        if self.relief!=0:
+            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())
+        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:
+        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_width,
+            )
         pygame.draw.rect(
             self.surface,
-            self._outline_color,
-            (0,0,*self.rect.size),
-            self._outline
+            self.outline_color,
+            (
+                0,
+                self.relief - self.get_relief(),
+                self.rect.w,
+                self.rect.h - (self.relief - self.get_relief()),
+            ),
+            self.outline_width,
         )
-    
-    def _build_rounded_outline(self)->None:
+
+    def _paint_rounded_outline(self) -> None:
+        e = self._get_elevated_rect()
+        b = e.copy()
+        b.h += e.bottom - b.bottom
+
         pygame.draw.rect(
             self.surface,
-            self._outline_color,
-            (0,0,*self.rect.size),
-            self._outline,
-            *self._border_radius
+            self.outline_color,
+            e,
+            self.outline_width,
+            *self.border_radius,
         )
+        if self.relief:
+            pygame.draw.rect(
+                self.surface,
+                self.outline_color,
+                b,
+                self.outline_width,
+                *self.border_radius,
+            )

batFramework/gui/slider.py

@@ -0,0 +1,230 @@
+import batFramework as bf
+from .meter import Meter
+from .button import Button
+from .indicator import *
+from .meter import Meter
+from .shape import Shape
+from .interactiveWidget import InteractiveWidget
+
+
+class SliderHandle(Indicator, DraggableWidget):
+    def __init__(self):
+        super().__init__()
+        self.set_color(bf.color.CLOUD_SHADE)
+        self.old_key_repeat: tuple = (0, 0)
+
+    def __str__(self) -> str:
+        return "SliderHandle"
+
+    def on_click_down(self, button: int) -> None:
+        super().on_click_down(button)
+        if button == 1:
+            self.parent.get_focus()
+
+    def on_exit(self) -> None:
+        self.is_hovered = False
+        self.do_on_exit()
+
+    def do_on_drag(
+        self, drag_start: tuple[float, float], drag_end: tuple[float, float]
+    ) -> None:
+        super().do_on_drag(drag_start, drag_end)
+        m: Meter = self.parent.meter
+        r = m.get_padded_rect()
+        position = self.rect.centerx
+        self.rect.clamp_ip(r)
+        # Adjust handle position to value
+        new_value = self.parent.position_to_value(position)
+        self.parent.set_value(new_value)
+        self.rect.centerx = self.parent.value_to_position(new_value)
+
+    def top_at(self, x, y):
+        return Widget.top_at(self, x, y)
+
+
+class SliderMeter(Meter, InteractiveWidget):
+
+    def __str__(self) -> str:
+        return "SliderMeter"
+
+    def on_click_down(self, button: int) -> None:
+        if button == 1:
+            self.parent.get_focus()
+            r = self.get_root()
+            if r:
+                pos = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())[0]
+                self.parent.set_value(self.parent.position_to_value(pos))
+
+        self.do_on_click_down(button)
+
+
+class Slider(Button):
+    def __init__(self, text: str, default_value: float = 1.0) -> None:
+        super().__init__(text, None)
+        self.gap: float | int = 0
+        self.spacing: bf.spacing = bf.spacing.MANUAL
+        self.modified_callback = None
+        self.meter: SliderMeter = SliderMeter()
+        self.handle = SliderHandle()
+        self.add(self.meter, self.handle)
+        self.meter.set_debug_color(bf.color.RED)
+        self.set_value(default_value, True)
+
+    def set_visible(self, value: bool) -> Self:
+        self.handle.set_visible(value)
+        self.meter.set_visible(value)
+        return super().set_visible(value)
+
+    def __str__(self) -> str:
+        return "Slider"
+
+    def set_gap(self, value: int | float) -> Self:
+        value = max(0, value)
+        self.gap = value
+        return self
+
+    def do_on_get_focus(self) -> None:
+        super().do_on_get_focus()
+        self.old_key_repeat = pygame.key.get_repeat()
+        pygame.key.set_repeat(200, 50)
+
+    def do_on_lose_focus(self) -> None:
+        super().do_on_lose_focus()
+        pygame.key.set_repeat(*self.old_key_repeat)
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        gap = self.gap if self.text else 0
+        if not self.text_rect:
+            self.text_rect.size = self._get_text_rect_required_size()
+        w, h = self.text_rect.size
+        return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.rect.w, h)).size
+
+    def set_spacing(self, spacing: bf.spacing) -> Self:
+        if spacing == self.spacing:
+            return self
+        self.spacing = spacing
+        self.dirty_shape = True
+        return self
+
+    def set_modify_callback(self, callback) -> Self:
+        self.modified_callback = callback
+        return self
+
+    def set_range(self, range_min: float, range_max: float) -> Self:
+        self.meter.set_range(range_min, range_max)
+        return self
+
+    def set_step(self, step: float) -> Self:
+        self.meter.set_step(step)
+        return self
+
+    def set_value(self, value, no_callback: bool = False) -> Self:
+        if self.meter.value != value:
+            self.meter.set_value(value)
+            self.dirty_shape = True
+        if self.modified_callback and (not no_callback):
+            self.modified_callback(self.meter.value)
+        return self
+
+    def get_value(self) -> float:
+        return self.meter.get_value()
+
+    def do_on_key_down(self, key):
+        if key == pygame.K_RIGHT:
+            self.set_value(self.meter.get_value() + self.meter.step)
+        elif key == pygame.K_LEFT:
+            self.set_value(self.meter.get_value() - self.meter.step)
+
+    def do_on_click_down(self, button) -> None:
+        if button == 1:
+            self.get_focus()
+
+    def value_to_position(self, value: float) -> float:
+        """
+        Converts a value to a position on the meter, considering the step size.
+        """
+        rect = self.meter.get_padded_rect()
+        value_range = self.meter.get_range()
+        value = round(value / self.meter.step) * self.meter.step
+        position_ratio = (value - self.meter.min_value) / value_range
+        return (
+            rect.left
+            + (self.handle.rect.w / 2)
+            + position_ratio * (rect.width - self.handle.rect.w)
+        )
+
+    def position_to_value(self, position: float) -> float:
+        """
+        Converts a position on the meter to a value, considering the step size.
+        """
+        handle_half = self.handle.rect.w / 2
+        rect = self.meter.get_padded_rect()
+        position = max(rect.left + handle_half, min(position, rect.right - handle_half))
+
+        position_ratio = (position - rect.left - handle_half) / (
+            rect.width - self.handle.rect.w
+        )
+        value_range = self.meter.get_range()
+        value = self.meter.min_value + position_ratio * value_range
+        return round(value / self.meter.step) * self.meter.step
+
+    def _build_layout(self) -> None:
+
+        gap = self.gap if self.text else 0
+
+        self.text_rect.size = self._get_text_rect_required_size()
+
+        meter_size = [self.text_rect.h * 10, self.font_object.point_size]
+        if not self.autoresize_w:
+            meter_size[0] = self.get_padded_width() - self.text_rect.w - gap
+
+        tmp_rect = pygame.FRect(
+            0, 0, self.text_rect.w + gap + meter_size[0], self.text_rect.h
+        )
+
+        if self.autoresize_h or self.autoresize_w:
+            target_rect = self.inflate_rect_by_padding(tmp_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
+        padded_rect = self.get_padded_rect()
+        padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
+
+
+        self.meter.set_size_if_autoresize(meter_size)
+
+        self.align_text(tmp_rect, padded_relative, self.alignment)
+        self.text_rect.midleft = tmp_rect.midleft
+
+        if self.text:
+            match self.spacing:
+                case bf.spacing.MAX:
+                    gap = padded_relative.right - self.text_rect.right - self.meter.rect.w
+                case bf.spacing.MIN:
+                    gap = 0
+
+        # place meter
+
+        self.meter.set_position(
+            *self.text_rect.move(
+                self.rect.x + gap,
+                self.rect.y + (self.text_rect.h / 2) - meter_size[1] / 2,
+            ).topright
+        )
+        # place handle
+
+        # print(self.meter.rect.top - self.rect.top)
+        # print(self.meter.rect.h)
+
+        x = self.value_to_position(self.meter.value)
+        r = self.meter.get_padded_rect()
+        self.handle.set_center(x, r.centery)
+
+        # self.handle.set_center(x,self.rect.top)

batFramework/gui/style.py

@@ -0,0 +1,10 @@
+from .widget import Widget
+
+
+class Style:
+
+    def __init__(self):
+        pass
+
+    def apply(self, widget: Widget):
+        pass

batFramework/gui/styleManager.py

@@ -0,0 +1,48 @@
+from ..utils import Singleton
+from .widget import Widget
+
+
+class Style:
+    def __init__(self):
+        pass
+
+    def apply(self, widget: Widget):
+        pass
+
+
+class StyleManager(metaclass=Singleton):
+    def __init__(self):
+        self.styles: list[Style] = []
+        self.widgets: set[Widget] = set()
+        self.lookup: dict[Widget, bool] = {}
+
+    def register_widget(self, widget: Widget):
+        if widget in self.widgets:
+            return
+        self.widgets.add(widget)
+        self.lookup[widget] = False
+        self.update()
+
+    def refresh_widget(self, widget: Widget):
+        if widget in self.widgets:
+            self.lookup[widget] = True
+            self.update()
+
+    def remove_widget(self, widget: Widget):
+        if widget not in self.widgets:
+            return
+        self.widgets.remove(widget)
+        self.lookup.pop(widget)
+
+    def add(self, style: Style):
+        self.styles.append(style)
+        self.lookup = {key: False for key in self.lookup}
+        self.update()
+
+    def update(self):
+        for widget in self.widgets:
+            if self.lookup[widget]:
+                continue
+            for style in self.styles:
+                style.apply(widget)
+            self.lookup[widget] = True