batframework 1.0.10__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

batFramework/gui/selector.py

@@ -0,0 +1,232 @@
+import batFramework as bf
+import pygame
+from typing import Self, Callable, Any
+from .button import Button
+from .indicator import ArrowIndicator
+from .clickableWidget import ClickableWidget
+from .widget import Widget
+from .syncedVar import SyncedVar
+
+class MyArrow(ArrowIndicator, ClickableWidget):
+    def top_at(self, x, y):
+        return Widget.top_at(self, x, y)
+
+    def get_focus(self):
+        return self.parent.get_focus()
+
+    def __str__(self):
+        return "SelectorArrow"
+
+class Selector(Button):
+    def __init__(self, options: list[Any] = None, default_value_index: int = None, display_func: Callable[[Any], str] = None,synced_var: SyncedVar = None):
+        self.allow_cycle = False
+        self.current_index = default_value_index
+        self.on_modify_callback: Callable[[Any, int], Any] = None
+        self.options = options if options else []
+        self.display_func = display_func or str
+        self.gap: int = 2
+        self.synced_var = synced_var if synced_var is not None else SyncedVar(None)
+        display_text = ""
+
+        super().__init__("")
+
+        self.left_indicator: MyArrow = (MyArrow(bf.direction.LEFT)
+            .set_color((0, 0, 0, 0)).set_arrow_color(self.text_widget.text_color)
+            .set_callback(lambda: self.set_by_index(self.get_current_index() - 1))
+        )
+
+        self.right_indicator: MyArrow = (MyArrow(bf.direction.RIGHT)
+            .set_color((0, 0, 0, 0)).set_arrow_color(self.text_widget.text_color)
+            .set_callback(lambda: self.set_by_index(self.get_current_index() + 1))
+        )
+
+        self.add(self.left_indicator, self.right_indicator)
+        self.set_clip_children(False)
+
+        if self.options and default_value_index is None and synced_var is not None:
+            display_text = display_func(synced_var.value)
+            default_value_index = self.options.index(synced_var.value)
+        elif self.options:
+            if default_value_index is None:
+                default_value_index= 0
+            display_text = self.display_func(self.options[default_value_index])
+        self.current_index = default_value_index
+        self.set_text(display_text)
+
+    def __str__(self):
+        return f"Selector[{self.options[self.current_index] if self.options else ''}]"
+
+    def _update_text_widget(self):
+        if self.options:
+            display_text = self.display_func(self.options[self.current_index])
+            self.text_widget.set_text(display_text)
+        else:
+            self.text_widget.set_text("")
+
+    def _on_synced_var_update(self, value: Any):
+        if value in self.options:
+            self.current_index = self.options.index(value)
+            self._update_text_widget()
+            self._update_arrow_states()
+            if self.on_modify_callback:
+                self.on_modify_callback(value, self.current_index)
+
+    def _update_arrow_states(self):
+        if not self.allow_cycle:
+            if self.current_index <= 0:
+                self.left_indicator.disable()
+            else:
+                self.left_indicator.enable()
+
+            if self.current_index >= len(self.options) - 1:
+                self.right_indicator.disable()
+            else:
+                self.right_indicator.enable()
+
+    def set_gap(self, value: int) -> Self:
+        self.gap = value
+        self.dirty_shape = True
+        return self
+
+    def set_arrow_color(self, color) -> Self:
+        self.left_indicator.set_arrow_color(color)
+        self.right_indicator.set_arrow_color(color)
+        return self
+
+    def disable(self):
+        super().disable()
+        self.left_indicator.disable()
+        self.right_indicator.disable()
+        return self
+
+    def enable(self):
+        super().enable()
+        self.left_indicator.enable()
+        self.right_indicator.enable()
+        self._update_arrow_states()
+        return self
+
+    def set_tooltip_text(self, text) -> Self:
+        self.left_indicator.set_tooltip_text(text)
+        self.right_indicator.set_tooltip_text(text)
+        return super().set_tooltip_text(text)
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        old_text = self.text_widget.get_text()
+        max_size = (0, 0)
+        for option in self.options:
+            self.text_widget.set_text(self.display_func(option))
+            size = self.text_widget.get_min_required_size()
+            max_size = (max(max_size[0], size[0]), max(max_size[1], size[1]))
+        self.text_widget.set_text(old_text)
+
+        # total_height = max(self.font_object.get_height() + 1, max_size[1] * 1.5)
+        total_height = max_size[1] if max_size[1] > 16 else max_size[1]*1.5
+        total_height += self.unpressed_relief
+        total_height += max(self.right_indicator.outline_width, self.left_indicator.outline_width)
+
+        total_width = total_height * 2 + max_size[0] + self.gap * 2
+
+        return self.expand_rect_with_padding((0, 0, total_width, total_height)).size
+
+    def _align_content(self):
+        padded = self.get_inner_rect()
+        indicator_height = padded.h
+        self.left_indicator.set_size((indicator_height, indicator_height))
+        self.right_indicator.set_size((indicator_height, indicator_height))
+
+        self.left_indicator.set_position(padded.left, None)
+        self.left_indicator.set_center(None, padded.centery)
+
+        right_size = self.right_indicator.rect.size
+        self.right_indicator.set_position(padded.right - right_size[0], None)
+        self.right_indicator.set_center(None, padded.centery)
+
+    def apply_post_updates(self, skip_draw=False):
+        super().apply_post_updates(skip_draw)
+        self._align_content()
+
+    def get_current_index(self) -> int:
+        return self.current_index
+
+    def set_allow_cycle(self, value: bool) -> Self:
+        if value != self.allow_cycle:
+            self.allow_cycle = value
+            self.dirty_surface = True
+            self._update_arrow_states()
+        return self
+
+    def set_text_color(self, color) -> Self:
+        super().set_text_color(color)
+        return self
+
+    def set_modify_callback(self, func: Callable[[Any, int], Any]) -> Self:
+        self.on_modify_callback = func
+        return self
+
+    def set_by_index(self, index: int) -> Self:
+        if self.allow_cycle:
+            index = index % len(self.options)
+        else:
+            index = max(min(len(self.options) - 1, index), 0)
+
+        if index == self.current_index:
+            return self
+
+        self.current_index = index
+        value = self.options[self.current_index]
+        display_text = self.display_func(value)
+        self.set_text(display_text)
+
+        self.synced_var.value = value
+
+        if self.on_modify_callback:
+            self.on_modify_callback(value, self.current_index)
+
+        if not self.allow_cycle:
+            if index == 0:
+                self.left_indicator.disable()
+            else:
+                self.left_indicator.enable()
+            if index == len(self.options) - 1:
+                self.right_indicator.disable()
+            else:
+                self.right_indicator.enable()
+
+        return self
+
+
+    def set_by_value(self, value: str) -> Self:
+        if not self.is_enabled:
+            return self
+        if value not in self.options:
+            return self
+        index = self.options.index(value)
+        self.set_by_index(index)
+        return self
+    
+    def on_key_down(self, key: int,event) -> None:
+        if not self.is_enabled:
+            return
+        key_actions = {
+            pygame.K_RIGHT: self.right_indicator,
+            pygame.K_SPACE: self.right_indicator,
+            pygame.K_LEFT: self.left_indicator,
+        }
+        indicator = key_actions.get(key)
+        if indicator and indicator.visible and indicator.is_enabled:
+            indicator.on_click_down(1,event)
+            event.consumed = True
+
+    def on_key_up(self, key: int,event) -> None:
+        if not self.is_enabled:
+            return 
+        key_actions = {
+            pygame.K_RIGHT: self.right_indicator,
+            pygame.K_SPACE: self.right_indicator,
+            pygame.K_LEFT: self.left_indicator,
+        }
+        indicator = key_actions.get(key)
+        if indicator and indicator.visible and indicator.is_enabled:
+            indicator.on_click_up(1,event)
+            event.consumed = True

batFramework/gui/shape.py

@@ -1,86 +1,286 @@
-import batFramework as bf
-from .widget import Widget
-import pygame
-
-
-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:
-        return "Shape"
-
-    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) -> "Frame":
-        self._outline_color = color
-        self.build()
-        return self
-
-    def set_border_radius(self,value:int|list[int]) -> "Frame":
-        if isinstance(value,int):
-            self._border_radius = [value]
-        else:
-            self._border_radius = value
-        self.build()
-        return self
-        
-    def set_outline_width(self,value:int) -> "Frame":
-        self._outline = value
-        self.build()
-        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()
-        else:
-            self._build_rounded_shape()
-            if self._outline : self._build_rounded_outline()
-
-
-    def _build_shape(self)->None:
-        self.surface.fill(self._color)
-
-    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
-        )
-
-    def _build_outline(self)->None:
-        pygame.draw.rect(
-            self.surface,
-            self._outline_color,
-            (0,0,*self.rect.size),
-            self._outline
-        )
-    
-    def _build_rounded_outline(self)->None:
-        pygame.draw.rect(
-            self.surface,
-            self._outline_color,
-            (0,0,*self.rect.size),
-            self._outline,
-            *self._border_radius
-        )
+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 = 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: pygame.typing.ColorLike = (0, 0, 0, 255)
+        self.texture_surface = None
+        self.texture_subsize = (0, 0)
+        self.relief = 0
+        self.shadow_color: pygame.typing.ColorLike = (0, 0, 0, 255)
+        self.draw_mode = bf.drawMode.SOLID
+
+    def get_inner_bottom(self) -> float:
+        return self.rect.bottom - self.padding[3] - self.relief
+
+    def get_inner_height(self) -> float:
+        return self.rect.h - self.padding[1] - self.padding[3] - self.relief
+
+    def get_inner_top(self) -> float:
+        return self.rect.y + self.padding[1]
+
+    def get_local_inner_rect(self)->pygame.FRect:
+        return pygame.FRect(
+            self.padding[0],
+            self.padding[1],
+            self.rect.w - self.padding[2] - self.padding[0],
+            self.rect.h - self.padding[1] - self.padding[3] - self.relief,
+        )
+
+    def get_inner_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: pygame.typing.ColorLike) -> 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:
+        return "Shape"
+
+    def set_color(self, color: pygame.typing.ColorLike) -> Self:
+        self.color = color
+        self.dirty_surface = True
+        return self
+
+    def set_outline_color(self, color: pygame.typing.ColorLike) -> Self:
+        self.outline_color = color
+        self.dirty_surface = True
+        return self
+
+    def set_border_radius(self, value: int | list[int]) -> Self:
+        if isinstance(value, int):
+            self.border_radius = [value]
+        else:
+            self.border_radius = value
+        self.dirty_surface = True
+        return self
+
+    def set_outline_width(self, value: int) -> Self:
+        self.outline_width = value
+        self.dirty_surface = True
+        return self
+
+    def paint(self) -> None:
+        self._resize_surface()
+        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._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))
+
+        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),
+                ),
+            ]
+        )
+
+        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:
+            if self.shadow_color is not None:
+                self.surface.fill(self.shadow_color, self._get_base_rect())
+            if self.color is not None:
+                self.surface.fill(self.color, self._get_elevated_rect())
+        
+        elif self.color is not None:
+                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
+            if self.shadow_color is not None:
+                pygame.draw.rect(self.surface, self.shadow_color, b, 0, *self.border_radius)
+            if self.color is not None:
+                pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
+        elif self.color is not None:
+                pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
+
+    def _paint_outline(self) -> None:
+        if self.outline_color is None:
+            return
+        pygame.draw.rect(
+            self.surface,
+            self.outline_color,
+            self._get_elevated_rect(),
+            self.outline_width,
+        )
+
+    def _paint_rounded_outline(self) -> None:
+        if self.outline_color is None:
+            return
+        e = self._get_elevated_rect()
+        b = e.copy()
+        b.h += e.bottom - b.bottom
+
+        pygame.draw.rect(
+            self.surface,
+            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,
+            )