batframework 1.0.6__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/gui/shape.py

@@ -1,79 +1,287 @@
 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 to_string_id(self) -> str:
+    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: 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 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":
+    def set_border_radius(self, value: int | list[int]) -> Self:
         if isinstance(value, int):
-            self._border_radius = [value]
+            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 = 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:
+                self._paint_outline()
         else:
-            self._build_rounded_shape()
-            if self._outline:
-                self._build_rounded_outline()
+            self._paint_rounded_shape()
+            if self.outline:
+                self._paint_rounded_outline()
+
 
-    def _build_shape(self) -> None:
-        self.surface.fill(self._color)
 
-    def _build_rounded_shape(self) -> None:
+    def _paint_textured(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
+        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))
+
+        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:
+        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())
+
+    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)
+
+    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, 0, *self.rect.size), self._outline
+            self.surface,
+            self.outline_color,
+            (
+                0,
+                self.relief - self.get_relief(),
+                self.rect.w,
+                self.rect.h - (self.relief - self.get_relief()),
+            ),
+            self.outline,
         )
 
-    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,
+            *self.border_radius,
         )
+        if self.relief:
+            pygame.draw.rect(
+                self.surface,
+                self.outline_color,
+                b,
+                self.outline,
+                *self.border_radius,
+            )

batFramework/gui/slider.py

@@ -1,5 +1,220 @@
 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 __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().set_color(bf.color.CLOUD)
+        self.add(self.meter,self.handle)
+        self.meter.set_debug_color(bf.color.RED)
+        self.set_value(default_value,True)
+        # print(self.handle.rect)
+        # self.handle.set_visible(False)
+        
+    def __str__(self) -> str:
+        return "Slider"
+
+    def set_gap(self, value: int | float) -> Self:
+        value = max(0, value)
+        self.gap = value
+        return self
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        gap = self.gap if self.text else 0
+        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()
+        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)
+            bf.AudioManager().play_sound(self.click_down_sound)
+        elif key == pygame.K_LEFT:
+            self.set_value(self.meter.get_value() - self.meter.step)
+            bf.AudioManager().play_sound(self.click_down_sound)
+            
+    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
+        # print(self.handle.rect)
+        # print(rect.left + (self.handle.rect.w/2) + position_ratio * (rect.width - self.handle.rect.w),self.handle.rect.w,self.rect.right)
+        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
+
+        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()
+
+        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 = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
+
+        self.meter.set_size_if_autoresize(meter_size)
+        handle_size = 2*[self.meter.get_padded_height()]
+        
+        self.handle.set_size_if_autoresize(handle_size)
+
+        self.align_text(tmp_rect,padded,self.alignment)
+        self.text_rect.midleft = tmp_rect.midleft
+
+        if self.text : 
+            match self.spacing:
+                case bf.spacing.MAX:
+                    gap = padded.w - self.text_rect.w - self.meter.rect.w
+                case bf.spacing.MIN:
+                    gap = 0
+                case bf.spacing.HALF:
+                    gap = (padded.w)/2 - self.text_rect.w
+
+        # 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)
 
-class Slider(bf.Widget):
-    pass