PlayPy 0.2.1__py3-none-any.whl

playpy/builtin.py

@@ -0,0 +1,638 @@
+import pygame as pg
+from pathlib import Path
+from typing import Callable, Literal
+import textwrap
+import os
+
+from . import state
+from . import elements
+from . import workspace
+from . import resources
+
+__all__ = [
+    "UIPadding",
+    "UIOutline",
+    "UIBorderRadius",
+    "UIGradient",
+    "UIFont",
+    "UIPanel",
+    "UIScrollablePanel",
+    "UIText",
+    "UIButton",
+    "UITextbox",
+    "Event",
+    "create_event",
+    "on_start",
+    "on_update",
+    "on_quit",
+    "on_scene_change",
+    "on_modal_change",
+    "on_hover",
+    "on_unhover",
+    "while_hovered",
+    "on_hover_inclusive",
+    "on_unhover_inclusive",
+    "while_hovered_inclusive",
+]
+
+class UIPadding(elements.UIModifier):
+    def __init__(
+            self,
+            scale: float = 0,
+            offset: int = 10
+        ) -> None:
+        super().__init__()
+        self.scale = scale
+        self.offset = offset
+
+class UIOutline(elements.UIModifier):
+    def __init__(
+        self,
+        color: state.ColorValue = (0, 0, 0),
+        width: int = 5,
+        edge_type: Literal["inset", "middle", "outset"] = "middle"
+    ):
+        super().__init__()
+        self.color = color
+        self.width = width
+        self.edge_type = edge_type
+
+class UIBorderRadius(elements.UIModifier):
+    def __init__(
+        self,
+        radius: int = 0,
+    ):
+        super().__init__()
+        self.radius = radius
+
+class UIGradient(elements.UIModifier):
+    def __init__(
+        self,
+        start_color: state.ColorValue = (0, 0, 0),
+        end_color: state.ColorValue = (255, 255, 255),
+        direction: Literal["vertical", "horizontal"] = "vertical",
+    ):
+        super().__init__()
+        self.start_color = start_color
+        self.end_color = end_color
+        self.direction = direction
+
+class UIFont(elements.UIModifier):
+    def __init__(
+        self,
+        font_path: str | Path | None = None,
+        font_size: int | None = None,
+        bold: bool | None = None,
+        italic: bool | None = None,
+        antialias: bool | None = None,
+    ):
+        super().__init__()
+        self.font_path = font_path
+        self.font_size = font_size
+        self.bold = bold
+        self.italic = italic
+        self.antialias = antialias
+
+class GlobalElement(elements.UIModifier):
+    def __init__(self):
+        super().__init__()
+
+def _lerp_color(a: state.ColorValue, b: state.ColorValue, t: float) -> tuple[int, int, int, int]:
+    if len(a) == 3:
+        a = (a[0], a[1], a[2], 255)
+    if len(b) == 3:
+        b = (b[0], b[1], b[2], 255)
+    return (
+        round(a[0] + (b[0] - a[0]) * t),
+        round(a[1] + (b[1] - a[1]) * t),
+        round(a[2] + (b[2] - a[2]) * t),
+        round(a[3] + (b[3] - a[3]) * t),
+    )
+
+
+def _resolve_font_path(font_path: str | Path | None) -> str | None:
+    if font_path is None:
+        return None
+    path = Path(font_path)
+    if not path.is_absolute():
+        candidate = os.curdir / path
+        if candidate.exists():
+            return str(candidate)
+    if path.exists():
+        return str(path)
+    return None
+
+def _wrap_text_to_width(font: pg.font.Font, text: str, max_width: int) -> list[str]:
+    if max_width <= 0:
+        return text.splitlines() if text else [""]
+    lines: list[str] = []
+    for raw_line in text.splitlines() or [""]:
+        if raw_line == "":
+            lines.append("")
+            continue
+        words = raw_line.split(" ")
+        current = ""
+        for word in words:
+            candidate = word if current == "" else f"{current} {word}"
+            if font.size(candidate)[0] <= max_width:
+                current = candidate
+            else:
+                if current:
+                    lines.append(current)
+                # If a single word is too long, hard-wrap it.
+                if font.size(word)[0] > max_width:
+                    # rough wrap by characters, then refine with font size
+                    approx = textwrap.wrap(word, width=max(1, int(len(word) * max_width / max(font.size(word)[0], 1))))
+                    for chunk in approx[:-1]:
+                        lines.append(chunk)
+                    current = approx[-1] if approx else ""
+                else:
+                    current = word
+        lines.append(current)
+    return lines
+
+
+class UIPanel(elements.UIElement):
+    def __init__(
+        self,
+        scale: state.FRect,
+        offset: state.Rect,
+        color: state.ColorValue,
+        visible: bool = True,
+        enabled: bool = True,
+        z: int = 0,
+        scrollable: bool = False,
+        scroll_speed: int = 40,
+    ):
+        super().__init__(scale, offset, visible, enabled, z)
+        self.color = color
+        self.scrollable = scrollable
+        self.scroll_speed = scroll_speed
+        self.scroll_y = 0
+
+    def handle_input(self, workspace: workspace.Workspace):
+        if not self.scrollable:
+            return
+        panel_rect = self.get_rect_px(workspace)
+        if panel_rect.collidepoint(workspace.input.mouse_pos):
+            if workspace.input.mouse_wheel != 0:
+                self.scroll_y -= workspace.input.mouse_wheel * self.scroll_speed
+                self.scroll_y = max(0, self.scroll_y)
+
+    def draw(self, workspace: "workspace.Workspace"):
+        radius_modifier = self.get_modifier(UIBorderRadius)
+        border_radius = -1
+
+        if radius_modifier is not None:
+            border_radius = radius_modifier.radius
+
+        rect = self.get_rect_px(workspace)
+
+        gradient_modifier = self.get_modifier(UIGradient)
+        if gradient_modifier is not None and rect.w > 0 and rect.h > 0:
+            surf = pg.Surface((rect.w, rect.h), pg.SRCALPHA)
+            if gradient_modifier.direction == "horizontal":
+                denom = max(1, rect.w - 1)
+                for x in range(rect.w):
+                    t = x / denom
+                    color = _lerp_color(gradient_modifier.start_color, gradient_modifier.end_color, t)
+                    pg.draw.line(surf, color, (x, 0), (x, rect.h - 1))
+            else:
+                denom = max(1, rect.h - 1)
+                for y in range(rect.h):
+                    t = y / denom
+                    color = _lerp_color(gradient_modifier.start_color, gradient_modifier.end_color, t)
+                    pg.draw.line(surf, color, (0, y), (rect.w - 1, y))
+            if border_radius >= 0:
+                mask = pg.Surface((rect.w, rect.h), pg.SRCALPHA)
+                pg.draw.rect(mask, (255, 255, 255, 255), mask.get_rect(), border_radius=border_radius)
+                surf.blit(mask, (0, 0), special_flags=pg.BLEND_RGBA_MULT)
+            workspace.screen.blit(surf, rect.topleft)
+        else:
+            pg.draw.rect(workspace.screen, self.color, rect, border_radius=border_radius)
+
+        outline_modifier = self.get_modifier(UIOutline)
+        if outline_modifier is not None:
+            xy_offset = (-2 if outline_modifier.edge_type == "outset" else -1 if outline_modifier.edge_type == "middle" else 0) * outline_modifier.width // 2
+
+            out_rect = rect.copy()
+
+            out_rect.x += xy_offset
+            out_rect.y += xy_offset
+            out_rect.w -= xy_offset * 2
+            out_rect.h -= xy_offset * 2
+
+            pg.draw.rect(workspace.screen, outline_modifier.color, out_rect, outline_modifier.width, border_radius=border_radius)
+
+
+class UIScrollablePanel(UIPanel):
+    def __init__(
+        self,
+        scale: state.FRect,
+        offset: state.Rect,
+        color: state.ColorValue,
+        visible: bool = True,
+        enabled: bool = True,
+        z: int = 0,
+        scroll_speed: int = 40,
+    ):
+        super().__init__(scale, offset, color, visible, enabled, z, scrollable=True, scroll_speed=scroll_speed)
+
+
+class UIText(elements.UIElement):
+    def __init__(
+        self,
+        scale: state.FRect,
+        offset: state.Rect,
+        text: str,
+        color: state.ColorValue = (0, 0, 0),
+        align: Literal[
+            "topleft", "topright", "midtop",
+            "midleft", "center", "midright",
+            "bottomleft", "bottomright", "midbottom",
+        ] = "topleft",
+        visible: bool = True,
+        enabled: bool = True,
+        z: int = 0,
+    ):
+        super().__init__(scale, offset, visible, enabled, z)
+        self.text = text
+        self.color = color
+        self.align = align
+
+    def draw(self, workspace: "workspace.Workspace"):
+        font_mod = self.get_modifier(UIFont)
+        font_path = None
+        font_size = 24
+        bold = False
+        italic = False
+        antialias = True
+
+        if font_mod is not None:
+            if font_mod.font_path is not None:
+                font_path = _resolve_font_path(font_mod.font_path)
+            if font_mod.font_size is not None:
+                font_size = font_mod.font_size
+            if font_mod.bold is not None:
+                bold = font_mod.bold
+            if font_mod.italic is not None:
+                italic = font_mod.italic
+            if font_mod.antialias is not None:
+                antialias = font_mod.antialias
+
+        font = pg.font.Font(font_path, font_size)
+        font.set_bold(bold)
+        font.set_italic(italic)
+        rect = self.get_rect_px(workspace)
+        lines = _wrap_text_to_width(font, self.text, rect.w)
+        line_h = font.get_linesize()
+        block_h = line_h * len(lines)
+
+        # Determine starting position based on alignment
+        if "top" in self.align:
+            start_y = rect.y
+        elif "bottom" in self.align:
+            start_y = rect.bottom - block_h
+        else:
+            start_y = rect.centery - block_h // 2
+
+        if "left" in self.align:
+            start_x = rect.x
+        elif "right" in self.align:
+            start_x = rect.right
+        else:
+            start_x = rect.centerx
+
+        for i, line in enumerate(lines):
+            surface = font.render(line, antialias, self.color)
+            text_rect = surface.get_rect()
+            if "left" in self.align:
+                text_rect.x = start_x
+            elif "right" in self.align:
+                text_rect.right = start_x
+            else:
+                text_rect.centerx = start_x
+            text_rect.y = start_y + i * line_h
+            workspace.screen.blit(surface, text_rect)
+
+    def handle_input(self, workspace: workspace.Workspace):
+        pass
+
+class UIButton(UIPanel):
+    def __init__(
+        self,
+        scale: state.FRect,
+        offset: state.Rect,
+        text: str,
+        on_click: Callable[[workspace.Workspace], None] | None = None,
+        color: state.ColorValue = (200, 200, 200),
+        hover_color: state.ColorValue | None = None,
+        pressed_color: state.ColorValue | None = None,
+        text_color: state.ColorValue = (0, 0, 0),
+        font_path: str | None = None,
+        font_size: int = 24,
+        visible: bool = True,
+        enabled: bool = True,
+        z: int = 0,
+    ):
+        super().__init__(scale, offset, color, visible, enabled, z)
+        self.on_click = on_click
+        self.idle_color = color
+        self.hover_color = hover_color if hover_color is not None else color
+        self.pressed_color = pressed_color if pressed_color is not None else color
+        self._pressed = False
+        self._label = UIText(
+            state.FRect(0, 0, 1, 1),
+            state.Rect(0, 0, 0, 0),
+            text=text,
+            color=text_color,
+            align="center",
+            enabled=False,
+            z=1,
+        )
+        self._label.parent = self
+        self._font_mod = UIFont(font_path=font_path, font_size=font_size)
+        self._label.set_modifier(self._font_mod)
+
+    @property
+    def label(self):
+        return self._label
+
+    @property
+    def text(self):
+        return self._label.text
+
+    @text.setter
+    def text(self, value: str):
+        self._label.text = value
+
+    @property
+    def text_color(self):
+        return self._label.color
+
+    @text_color.setter
+    def text_color(self, value: state.ColorValue):
+        self._label.color = value
+
+    @property
+    def font_path(self):
+        return self._font_mod.font_path
+
+    @font_path.setter
+    def font_path(self, value: str | None):
+        self._font_mod.font_path = value
+
+    @property
+    def font_size(self):
+        return self._font_mod.font_size
+
+    @font_size.setter
+    def font_size(self, value: int):
+        self._font_mod.font_size = value
+
+    def draw(self, workspace: "workspace.Workspace"):
+        self.color = self.idle_color
+        if self.is_mouse_over(workspace):
+            self.color = self.hover_color
+        if self._pressed:
+            self.color = self.pressed_color
+        super().draw(workspace)
+
+    def handle_input(self, workspace: workspace.Workspace):
+        if self.is_mouse_top(workspace) and self.is_mouse_over(workspace):
+            if workspace.input.mousebutton_down(state.MouseButton.LEFT):
+                self._pressed = True
+        if self._pressed and workspace.input.mousebutton_up(state.MouseButton.LEFT):
+            if self.is_mouse_top(workspace):
+                if self.on_click is not None:
+                    self.on_click(workspace)
+            self._pressed = False
+
+
+class UITextbox(UIPanel):
+    def __init__(
+        self,
+        scale: state.FRect,
+        offset: state.Rect,
+        text: str = "",
+        placeholder: str = "",
+        color: state.ColorValue = (255, 255, 255),
+        font_path: str | None = None,
+        font_size: int = 24,
+        text_color: state.ColorValue = (0, 0, 0),
+        placeholder_color: state.ColorValue = (120, 120, 120),
+        align: Literal['topleft', 'topright', 'midtop', 'midleft', 'center', 'midright', 'bottomleft', 'bottomright', 'midbottom'] = "topleft",
+        max_length: int | None = None,
+        visible: bool = True,
+        enabled: bool = True,
+        z: int = 0,
+    ):
+        super().__init__(scale, offset, color, visible, enabled, z)
+        self.text = text
+        self.placeholder = placeholder
+        self.text_color = text_color
+        self.placeholder_color = placeholder_color
+        self._value_label = UIText(state.FRect(0, 0, 1, 1), state.Rect(0, 0, 0, 0), "", self.placeholder_color, align, enabled=False)
+        self._value_label.parent = self
+        self._font_mod = UIFont(font_path=font_path, font_size=font_size)
+        self._value_label.set_modifier(self._font_mod)
+        self.max_length = max_length
+        self.focused = False
+        self._caret_visible = True
+        self._caret_timer = 0.0
+
+    @property
+    def value_label(self):
+        return self._value_label
+    
+    @property
+    def font_path(self):
+        return self._font_mod.font_path
+    
+    @font_path.setter
+    def font_path(self, value: str | None):
+        self._font_mod.font_path = value
+
+    @property
+    def font_size(self):
+        return self._font_mod.font_size
+
+    @font_size.setter
+    def font_size(self, value: int):
+        self._font_mod.font_size = value
+
+    def draw(self, workspace: "workspace.Workspace"):
+        super().draw(workspace)
+        display_text = self.text if self.text else self.placeholder
+        color = self.text_color if self.text else self.placeholder_color
+        self._value_label.text = display_text
+        self._value_label.color = color
+        
+        rect = self.get_rect_px(workspace)
+
+        if self.focused:
+            self._caret_timer += workspace.input.dt
+            if self._caret_timer > 0.5:
+                self._caret_timer = 0.0
+                self._caret_visible = not self._caret_visible
+            if self._caret_visible:
+                caret_x = self._value_label.get_rect_px(workspace).right + 2
+                caret_y1 = rect.y + 6
+                caret_y2 = rect.y + rect.h - 6
+                pg.draw.line(workspace.screen, self.text_color, (caret_x, caret_y1), (caret_x, caret_y2), 2)
+
+    def handle_input(self, workspace: workspace.Workspace):
+        if workspace.input.mousebutton_down(state.MouseButton.LEFT):
+            self.focused = self.is_mouse_top(workspace) and self.is_mouse_over(workspace)
+
+        if not self.focused:
+            return
+
+        for key in workspace.input.key_downs:
+            if key == state.Key.BACKSPACE:
+                self.text = self.text[:-1]
+            elif key == state.Key.RETURN:
+                pass
+
+        for chunk in workspace.input.text_input:
+            if not chunk:
+                continue
+            if any(ord(ch) < 32 for ch in chunk):
+                continue
+            if self.max_length is not None and len(self.text) >= self.max_length:
+                break
+            self.text += chunk
+
+class Event(elements.UIElement):
+    def __init__(
+        self,
+        condition_function: Callable[[workspace.Workspace], bool],
+        event_function: Callable[[workspace.Workspace], None],
+        negative_function: Callable[[workspace.Workspace], None] | None = None,
+        enabled: bool = True,
+        once: bool = False,
+        global_event: bool = True,
+    ):
+        super().__init__(state.empty_frect(), state.empty_rect(), False, enabled, 9999)
+        self.event_func = event_function
+        self.cond_func = condition_function
+        self.neg_func = negative_function
+        self.once = once
+
+        if global_event:
+            GlobalElement().parent = self
+
+    def draw(self, workspace: workspace.Workspace):
+        pass
+
+    def handle_input(self, workspace: workspace.Workspace):
+        if self.cond_func(workspace):
+            self.event_func(workspace)
+            if self.once:
+                self.enabled = False
+        elif self.neg_func:
+            self.neg_func(workspace)
+            if self.once:
+                self.enabled = False
+
+def create_event(target: workspace.Workspace | elements.UIElement, cond_func: Callable[[workspace.Workspace], bool]):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        new_event = Event(cond_func, event_func)
+        new_event.parent = target
+    return wrapper
+
+
+def on_start(target: workspace.Workspace | elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        if isinstance(target, elements.Scene):
+            new_event = Event(lambda w, scene=target: w.current_scene is scene, event_func)
+            new_event.parent = target
+            return
+        elif isinstance(target, elements.UIElement):
+            new_event = Event(lambda w, modal=target: w.current_modal is modal, event_func)
+            new_event.parent = target
+            return
+        new_event = Event(lambda w: w.input.runtime == 0, event_func, once=True)
+        new_event.parent = target
+    return wrapper
+
+
+def on_update(target: workspace.Workspace | elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        if isinstance(target, elements.Scene):
+            new_event = Event(lambda w, scene=target: w.current_scene is scene, event_func)
+            new_event.parent = target
+            return
+        elif isinstance(target, elements.UIElement):
+            new_event = Event(lambda w, modal=target: w.current_modal is modal, event_func)
+            new_event.parent = target
+            return
+        new_event = Event(lambda w: True, event_func)
+        new_event.parent = target
+    return wrapper
+
+
+def on_quit(target: workspace.Workspace | elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        new_event = Event(lambda w: w.input.quit, event_func)
+        new_event.parent = target
+    return wrapper
+
+
+def on_scene_change(target: workspace.Workspace | elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        if isinstance(target, elements.Scene):
+            new_event = Event(
+                lambda w, scene=target: w.scene_changed and w.current_scene is scene,
+                event_func,
+            )
+            new_event.parent = target
+            return
+        new_event = Event(lambda w: w.scene_changed, event_func)
+        new_event.parent = target
+    return wrapper
+
+
+def on_modal_change(target: workspace.Workspace | elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        if isinstance(target, elements.UIElement) and not isinstance(target, elements.Scene):
+            new_event = Event(
+                lambda w, modal=target: w.modal_changed and w.active_modal is modal,
+                event_func,
+            )
+            new_event.parent = target
+            return
+        new_event = Event(lambda w: w.modal_changed, event_func)
+        new_event.parent = target
+    return wrapper
+
+def on_hover(target: workspace.Workspace | elements.UIElement, hovered: elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        Event(lambda w: w.just_hovered(hovered), event_func).parent = target
+    return wrapper
+
+def on_unhover(target: workspace.Workspace | elements.UIElement, hovered: elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        Event(lambda w: w.just_unhovered(hovered), event_func).parent = target
+    return wrapper
+
+def while_hovered(target: workspace.Workspace | elements.UIElement, hovered: elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        Event(lambda w: w.is_mouse_top(hovered), event_func).parent = target
+    return wrapper
+
+def on_hover_inclusive(target: workspace.Workspace | elements.UIElement, hovered: elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        Event(lambda w: w.just_hovered_inclusive(hovered), event_func).parent = target
+    return wrapper
+
+def on_unhover_inclusive(target: workspace.Workspace | elements.UIElement, hovered: elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        Event(lambda w: w.just_unhovered_inclusive(hovered), event_func).parent = target
+    return wrapper
+
+def while_hovered_inclusive(target: workspace.Workspace | elements.UIElement, hovered: elements.UIElement):
+    def wrapper(event_func: Callable[[workspace.Workspace], None]):
+        Event(lambda w: w.is_mouse_over(hovered), event_func).parent = target
+    return wrapper
+

playpy/data/default_icon.ppm

@@ -0,0 +1,5 @@
+P3
+2 2
+255
+20 20 20  50 50 50
+50 50 50  20 20 20