nyuGUI 0.1.0__tar.gz

nyugui-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: nyuGUI
+Version: 0.1.0
+Summary: A lightweight GUI library featuring dynamic scale/offset layouting.
+Author: Wjanek13
+Project-URL: Documentation, https://nyugui-documentation.netlify.app
+Requires-Python: >=3.8
+Requires-Dist: pygame>=2.0.0

nyugui-0.1.0/nyuGUI/__init__.py

@@ -0,0 +1,21 @@
+# nyugui/__init__.py
+
+from nyuGUI.core import Dim, Widget, Root
+from nyuGUI.widgets import (
+    TextLabel,
+    Button,
+    ImageLabel,
+    TextInput,
+    ScrollingFrame,
+)
+
+__all__ = [
+    "Dim",
+    "Widget",
+    "Root",
+    "TextLabel",
+    "Button",
+    "ImageLabel",
+    "TextInput",
+    "ScrollingFrame",
+]

nyugui-0.1.0/nyuGUI/core.py

@@ -0,0 +1,322 @@
+import os
+import sys
+import ctypes
+import warnings
+from typing import Optional
+
+os.environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "1"
+warnings.filterwarnings("ignore", category=UserWarning, module="pygame")
+
+import pygame
+
+
+class Dim:
+    __slots__ = ("scale", "offset")
+
+    def __init__(self, scale: float = 0.0, offset: int = 0):
+        self.scale = float(scale)
+        self.offset = int(offset)
+
+    def calculate(self, parent_size: int) -> int:
+        return int(parent_size * self.scale + self.offset)
+
+    def __repr__(self) -> str:
+        return f"Dim(scale={self.scale}, offset={self.offset})"
+
+
+class Widget:
+    _creation_counter = 0
+
+    def __init__(
+        self,
+        x: Dim = None,
+        y: Dim = None,
+        width: Dim = None,
+        height: Dim = None,
+        parent=None,
+        bgcolor=None,
+        background_transparency: float = 0.0,
+        zindex: int = 0,
+        visible: bool = True,
+    ):
+        Widget._creation_counter += 1
+        self.age = Widget._creation_counter
+
+        self.x_dim = x if x is not None else Dim()
+        self.y_dim = y if y is not None else Dim()
+        self.w_dim = width if width is not None else Dim()
+        self.h_dim = height if height is not None else Dim()
+
+        self.bgcolor = bgcolor
+        self._background_transparency = max(0.0, min(1.0, float(background_transparency)))
+        self.zindex = zindex
+        self.parent = parent
+        self.visible = visible
+        self.is_hovered = False
+
+        self.children = []
+
+        self.real_x = 0
+        self.real_y = 0
+        self.real_width = 0
+        self.real_height = 0
+
+        if self.parent:
+            self.parent.add_child(self)
+
+    @property
+    def background_transparency(self) -> float:
+        return self._background_transparency
+
+    @background_transparency.setter
+    def background_transparency(self, value: float):
+        self._background_transparency = max(0.0, min(1.0, float(value)))
+
+    @property
+    def is_globally_visible(self) -> bool:
+        current = self
+        while current is not None:
+            if not current.visible:
+                return False
+            current = current.parent
+        return True
+
+    def add_child(self, child: "Widget"):
+        if child not in self.children:
+            child.parent = self
+            self.children.append(child)
+
+    def remove_child(self, child: "Widget"):
+        if child in self.children:
+            child.parent = None
+            self.children.remove(child)
+
+    def get_sorted_children(self):
+        return sorted(self.children, key=lambda w: (w.zindex, w.age))
+
+    def contains_point(self, px: int, py: int) -> bool:
+        return (self.real_x <= px < self.real_x + self.real_width) and (
+            self.real_y <= py < self.real_y + self.real_height
+        )
+
+    def resolve_layout(self, parent_x: int, parent_y: int, parent_w: int, parent_h: int):
+        self.real_width = self.w_dim.calculate(parent_w)
+        self.real_height = self.h_dim.calculate(parent_h)
+        self.real_x = parent_x + self.x_dim.calculate(parent_w)
+        self.real_y = parent_y + self.y_dim.calculate(parent_h)
+
+        for child in self.children:
+            child.resolve_layout(self.real_x, self.real_y, self.real_width, self.real_height)
+
+    def handle_event(self, event) -> bool:
+        if not self.is_globally_visible:
+            return False
+
+        if event.type == pygame.MOUSEMOTION:
+            self.is_hovered = self.contains_point(*event.pos)
+
+        for child in reversed(self.get_sorted_children()):
+            if child.handle_event(event):
+                return True
+
+        return False
+
+    def draw_background(self, surface: pygame.Surface):
+        if self.bgcolor and self.background_transparency < 1.0 and self.real_width > 0 and self.real_height > 0:
+            alpha = int(255 * (1.0 - self.background_transparency))
+            if alpha == 255:
+                pygame.draw.rect(
+                    surface,
+                    self.bgcolor,
+                    (self.real_x, self.real_y, self.real_width, self.real_height),
+                )
+            else:
+                bg_surface = pygame.Surface((self.real_width, self.real_height), pygame.SRCALPHA)
+                bg_color_with_alpha = (*self.bgcolor[:3], alpha)
+                bg_surface.fill(bg_color_with_alpha)
+                surface.blit(bg_surface, (self.real_x, self.real_y))
+
+    def draw_foreground(self, surface: pygame.Surface):
+        pass
+
+    def draw(self, surface: pygame.Surface):
+        if not self.is_globally_visible:
+            return
+
+        self.draw_background(surface)
+
+        prev_clip = surface.get_clip()
+        widget_rect = pygame.Rect(self.real_x, self.real_y, self.real_width, self.real_height)
+        surface.set_clip(widget_rect.clip(prev_clip))
+
+        for child in self.get_sorted_children():
+            child.draw(surface)
+
+        surface.set_clip(prev_clip)
+
+        self.draw_foreground(surface)
+
+    def _collect_flat(self, out: list, clip: "pygame.Rect"):
+        if not self.visible:
+            return
+
+        out.append((self, clip))
+
+        own_rect = pygame.Rect(self.real_x, self.real_y, self.real_width, self.real_height)
+        child_clip = own_rect.clip(clip)
+
+        for child in self.children:
+            child._collect_flat(out, child_clip)
+
+
+SDL_WINDOWEVENT = 0x200
+
+
+class _SDL_Event(ctypes.Structure):
+    _fields_ = [("type", ctypes.c_uint32), ("padding", ctypes.c_ubyte * 52)]
+
+
+_WATCH_FUNC_TYPE = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.POINTER(_SDL_Event))
+
+
+def _find_sdl2():
+    if hasattr(pygame, "get_sdl_dll_file"):
+        try:
+            return ctypes.CDLL(pygame.get_sdl_dll_file())
+        except Exception:
+            pass
+
+    candidates = ["SDL2.dll", "libSDL2-2.0.so.0", "libSDL2.so", "libSDL2-2.0.0.dylib"]
+    for name in candidates:
+        try:
+            return ctypes.CDLL(name)
+        except OSError:
+            continue
+
+    raise OSError("Could not locate the SDL2 library.")
+
+
+def install_resize_watcher(root: "Root"):
+    sdl2 = _find_sdl2()
+
+    def _watch(_userdata, event):
+        if event.contents.type == SDL_WINDOWEVENT:
+            root.update_layout()
+            root.render()
+        return 0
+
+    root._resize_watch_cb = _WATCH_FUNC_TYPE(_watch)
+    sdl2.SDL_AddEventWatch(root._resize_watch_cb, None)
+
+
+def cleanup_resize_watcher(root: "Root"):
+    if hasattr(root, "_resize_watch_cb"):
+        try:
+            sdl2 = _find_sdl2()
+            sdl2.SDL_DelEventWatch(root._resize_watch_cb, None)
+        except Exception:
+            pass
+
+
+from pathlib import Path
+import pygame
+
+PACKAGE_DIR = Path(__file__).parent
+DEFAULT_ICON_PATH = PACKAGE_DIR / "assets" / "logo.png"
+
+
+class Root(Widget):
+    def __init__(
+        self,
+        width: int = 800,
+        height: int = 600,
+        title: str = "nyuGUI App",
+        icon: Optional[str] = None,
+        bgcolor=(30, 30, 30),
+        resizable: bool = True,
+        fps: int = 60,
+        live_resize: bool = True,
+        global_zindex: bool = False,
+    ):
+        pygame.init()
+        pygame.font.init()
+
+        icon_to_load = icon if icon else DEFAULT_ICON_PATH
+        if Path(icon_to_load).exists():
+            try:
+                icon_surface = pygame.image.load(str(icon_to_load))
+                pygame.display.set_icon(icon_surface)
+            except Exception as e:
+                print(f"[nyuGUI] Warning: Failed to load icon '{icon_to_load}': {e}")
+
+        flags = pygame.RESIZABLE if resizable else 0
+        self.surface = pygame.display.set_mode((width, height), flags)
+        pygame.display.set_caption(title)
+        self.clock = pygame.time.Clock()
+        self.fps = fps
+        self.is_running = False
+        self.global_zindex = global_zindex
+
+        super().__init__(
+            x=Dim(0, 0),
+            y=Dim(0, 0),
+            width=Dim(1.0, 0),
+            height=Dim(1.0, 0),
+            parent=None,
+            bgcolor=bgcolor,
+            zindex=0,
+        )
+
+        if resizable and live_resize:
+            try:
+                install_resize_watcher(self)
+            except OSError as e:
+                print(f"[nyuGUI] live-resize watcher disabled: {e}")
+
+    def update_layout(self):
+        win_w, win_h = self.surface.get_size()
+        self.resolve_layout(0, 0, win_w, win_h)
+
+    def run_frame(self, events):
+        for event in events:
+            self.handle_event(event)
+
+    def _render_flat(self):
+        win_w, win_h = self.surface.get_size()
+        flat = []
+        self._collect_flat(flat, pygame.Rect(0, 0, win_w, win_h))
+
+        flat.sort(key=lambda item: (item[0].zindex, item[0].age))
+
+        for widget, clip in flat:
+            self.surface.set_clip(clip)
+            widget.draw_background(self.surface)
+            widget.draw_foreground(self.surface)
+
+        self.surface.set_clip(None)
+
+    def render(self):
+        if self.global_zindex:
+            self._render_flat()
+        else:
+            self.draw(self.surface)
+        pygame.display.flip()
+
+    def run(self):
+        self.is_running = True
+
+        while self.is_running:
+            events = pygame.event.get()
+            for event in events:
+                if event.type == pygame.QUIT:
+                    self.is_running = False
+
+            self.update_layout()
+            self.run_frame(events)
+            self.render()
+
+            self.clock.tick(self.fps)
+
+        cleanup_resize_watcher(self)
+        pygame.quit()
+        sys.exit()

nyugui-0.1.0/nyuGUI/widgets.py

@@ -0,0 +1,831 @@
+from typing import Callable, Optional, Union
+import pygame
+
+from nyuGUI.core import Dim, Widget
+
+
+class TextLabel(Widget):
+    _font_cache = {}
+
+    def __init__(
+        self,
+        text: str = "",
+        font_size: int = 18,
+        font_name: str = "Segoe UI",
+        text_color=(255, 255, 255),
+        align: str = "center",
+        text_visible: bool = True,
+        text_transparency: float = 0.0,
+        x: Dim = None,
+        y: Dim = None,
+        width: Dim = None,
+        height: Dim = None,
+        parent=None,
+        bgcolor=None,
+        background_transparency: float = 0.0,
+        zindex: int = 0,
+        visible: bool = True,
+    ):
+        self._text = text
+        self.font_size = font_size
+        self.font_name = font_name
+        self.text_color = text_color
+        self.align = align.lower()
+        self.text_visible = text_visible
+        self._text_transparency = max(0.0, min(1.0, float(text_transparency)))
+
+        self.rendered_surface = None
+        self._dirty = True
+
+        font_key = (self.font_name, self.font_size)
+        if font_key not in TextLabel._font_cache:
+            TextLabel._font_cache[font_key] = pygame.font.SysFont(self.font_name, self.font_size)
+        self.font = TextLabel._font_cache[font_key]
+
+        super().__init__(
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            parent=parent,
+            bgcolor=bgcolor,
+            background_transparency=background_transparency,
+            zindex=zindex,
+            visible=visible,
+        )
+
+        self._render_text()
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    @text.setter
+    def text(self, value: str):
+        if self._text != value:
+            self._text = value
+            self._dirty = True
+
+    @property
+    def text_transparency(self) -> float:
+        return self._text_transparency
+
+    @text_transparency.setter
+    def text_transparency(self, value: float):
+        value = max(0.0, min(1.0, float(value)))
+        if self._text_transparency != value:
+            self._text_transparency = value
+            self._dirty = True
+
+    def _render_text(self):
+        if self._dirty or self.rendered_surface is None:
+            raw_surface = self.font.render(self._text, True, self.text_color)
+            alpha = int(255 * (1.0 - self._text_transparency))
+
+            self.rendered_surface = raw_surface.convert_alpha()
+            self.rendered_surface.set_alpha(alpha)
+
+            self._dirty = False
+
+            if self.w_dim.scale == 0.0 and self.w_dim.offset == 0:
+                self.w_dim.offset = self.rendered_surface.get_width()
+            if self.h_dim.scale == 0.0 and self.h_dim.offset == 0:
+                self.h_dim.offset = self.rendered_surface.get_height()
+
+    def draw_foreground(self, surface: pygame.Surface):
+        if not self.text_visible or self.text_transparency >= 1.0:
+            return
+
+        self._render_text()
+        if not self.rendered_surface:
+            return
+
+        txt_w, txt_h = self.rendered_surface.get_size()
+        draw_y = self.real_y + (self.real_height - txt_h) // 2
+
+        if self.align == "left":
+            draw_x = self.real_x
+        elif self.align == "right":
+            draw_x = self.real_x + (self.real_width - txt_w)
+        else:
+            draw_x = self.real_x + (self.real_width - txt_w) // 2
+
+        surface.blit(self.rendered_surface, (draw_x, draw_y))
+
+
+class Button(TextLabel):
+    def __init__(
+        self,
+        text: str = "Button",
+        font_size: int = 18,
+        font_name: str = "Segoe UI",
+        text_color=(255, 255, 255),
+        align: str = "center",
+        text_visible: bool = True,
+        text_transparency: float = 0.0,
+        x: Dim = None,
+        y: Dim = None,
+        width: Dim = None,
+        height: Dim = None,
+        parent=None,
+        bgcolor=(0, 120, 215),
+        hover_bgcolor=(0, 140, 240),
+        pressed_bgcolor=(0, 90, 170),
+        background_transparency: float = 0.0,
+        zindex: int = 0,
+        visible: bool = True,
+        on_press: Optional[Callable[[], None]] = None,
+        on_release: Optional[Callable[[], None]] = None,
+    ):
+        super().__init__(
+            text=text,
+            font_size=font_size,
+            font_name=font_name,
+            text_color=text_color,
+            align=align,
+            text_visible=text_visible,
+            text_transparency=text_transparency,
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            parent=parent,
+            bgcolor=bgcolor,
+            background_transparency=background_transparency,
+            zindex=zindex,
+            visible=visible,
+        )
+
+        self.normal_bgcolor = bgcolor
+        self.hover_bgcolor = hover_bgcolor
+        self.pressed_bgcolor = pressed_bgcolor
+
+        self.on_press = on_press
+        self.on_release = on_release
+
+        self.is_pressed = False
+
+    def handle_event(self, event) -> bool:
+        if not self.is_globally_visible:
+            return False
+
+        if super().handle_event(event):
+            return True
+
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if self.contains_point(*event.pos):
+                self.is_pressed = True
+                if self.on_press:
+                    self.on_press()
+                return True
+
+        elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
+            if self.is_pressed:
+                self.is_pressed = False
+                if self.contains_point(*event.pos):
+                    if self.on_release:
+                        self.on_release()
+                return True
+
+        return False
+
+    def draw_background(self, surface: pygame.Surface):
+        original_bgcolor = self.bgcolor
+        if self.is_pressed and self.pressed_bgcolor:
+            self.bgcolor = self.pressed_bgcolor
+        elif self.is_hovered and self.hover_bgcolor:
+            self.bgcolor = self.hover_bgcolor
+        else:
+            self.bgcolor = self.normal_bgcolor
+
+        super().draw_background(surface)
+        self.bgcolor = original_bgcolor
+
+
+class ImageLabel(Widget):
+    _image_cache = {}
+
+    def __init__(
+        self,
+        image: Optional[Union[str, pygame.Surface]] = None,
+        scale_mode: str = "fit",
+        image_transparency: float = 0.0,
+        x: Dim = None,
+        y: Dim = None,
+        width: Dim = None,
+        height: Dim = None,
+        parent=None,
+        bgcolor=None,
+        background_transparency: float = 0.0,
+        zindex: int = 0,
+        visible: bool = True,
+    ):
+        super().__init__(
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            parent=parent,
+            bgcolor=bgcolor,
+            background_transparency=background_transparency,
+            zindex=zindex,
+            visible=visible,
+        )
+
+        self.scale_mode = scale_mode.lower()
+        self._image_transparency = max(0.0, min(1.0, float(image_transparency)))
+
+        self._source_image: Optional[pygame.Surface] = None
+        self._scaled_image: Optional[pygame.Surface] = None
+        self._last_draw_size = (0, 0)
+
+        if image is not None:
+            self.set_image(image)
+
+    @property
+    def image_transparency(self) -> float:
+        return self._image_transparency
+
+    @image_transparency.setter
+    def image_transparency(self, value: float):
+        value = max(0.0, min(1.0, float(value)))
+        if self._image_transparency != value:
+            self._image_transparency = value
+            self._scaled_image = None
+
+    def set_image(self, image: Union[str, pygame.Surface]):
+        if isinstance(image, str):
+            if image not in ImageLabel._image_cache:
+                loaded = pygame.image.load(image).convert_alpha()
+                ImageLabel._image_cache[image] = loaded
+            self._source_image = ImageLabel._image_cache[image]
+        elif isinstance(image, pygame.Surface):
+            self._source_image = image.convert_alpha()
+        else:
+            self._source_image = None
+
+        self._scaled_image = None
+
+        if self._source_image and self.w_dim.scale == 0.0 and self.w_dim.offset == 0:
+            self.w_dim.offset = self._source_image.get_width()
+        if self._source_image and self.h_dim.scale == 0.0 and self.h_dim.offset == 0:
+            self.h_dim.offset = self._source_image.get_height()
+
+    def _get_scaled_surface(self, target_w: int, target_h: int) -> Optional[pygame.Surface]:
+        if not self._source_image or target_w <= 0 or target_h <= 0:
+            return None
+
+        if self._scaled_image and self._last_draw_size == (target_w, target_h):
+            return self._scaled_image
+
+        src_w, src_h = self._source_image.get_size()
+        mode = self.scale_mode
+
+        if mode == "stretch":
+            scaled = pygame.transform.smoothscale(self._source_image, (target_w, target_h))
+
+        elif mode == "fit":
+            scale = min(target_w / src_w, target_h / src_h)
+            new_w, new_h = max(1, int(src_w * scale)), max(1, int(src_h * scale))
+            scaled = pygame.transform.smoothscale(self._source_image, (new_w, new_h))
+
+        elif mode == "crop":
+            scale = max(target_w / src_w, target_h / src_h)
+            new_w, new_h = max(1, int(src_w * scale)), max(1, int(src_h * scale))
+            resized = pygame.transform.smoothscale(self._source_image, (new_w, new_h))
+            
+            crop_x = (new_w - target_w) // 2
+            crop_y = (new_h - target_h) // 2
+            scaled = resized.subsurface((crop_x, crop_y, target_w, target_h)).copy()
+
+        else:
+            scaled = self._source_image.copy()
+
+        alpha = int(255 * (1.0 - self._image_transparency))
+        if alpha < 255:
+            scaled = scaled.copy()
+            scaled.set_alpha(alpha)
+
+        self._scaled_image = scaled
+        self._last_draw_size = (target_w, target_h)
+        return self._scaled_image
+
+    def draw_foreground(self, surface: pygame.Surface):
+        if not self._source_image or self.image_transparency >= 1.0:
+            return
+
+        img_surface = self._get_scaled_surface(self.real_width, self.real_height)
+        if not img_surface:
+            return
+
+        img_w, img_h = img_surface.get_size()
+
+        draw_x = self.real_x + (self.real_width - img_w) // 2
+        draw_y = self.real_y + (self.real_height - img_h) // 2
+
+        surface.blit(img_surface, (draw_x, draw_y))
+
+
+class TextInput(TextLabel):
+    def __init__(
+        self,
+        text: str = "",
+        placeholder: str = "Enter text...",
+        placeholder_color=(140, 140, 140),
+        font_size: int = 18,
+        font_name: str = "Segoe UI",
+        text_color=(255, 255, 255),
+        align: str = "left",
+        x: Dim = None,
+        y: Dim = None,
+        width: Dim = None,
+        height: Dim = None,
+        parent=None,
+        bgcolor=(40, 40, 40),
+        focused_bgcolor=(50, 50, 50),
+        hover_bgcolor=(45, 45, 45),
+        border_color=(100, 100, 100),
+        focused_border_color=(0, 120, 215),
+        cursor_color=(255, 255, 255),
+        background_transparency: float = 0.0,
+        zindex: int = 0,
+        visible: bool = True,
+        on_text_changed: Optional[Callable[[str], None]] = None,
+        on_submit: Optional[Callable[[str], None]] = None,
+    ):
+        super().__init__(
+            text=text,
+            font_size=font_size,
+            font_name=font_name,
+            text_color=text_color,
+            align=align,
+            text_visible=True,
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            parent=parent,
+            bgcolor=bgcolor,
+            background_transparency=background_transparency,
+            zindex=zindex,
+            visible=visible,
+        )
+
+        self.placeholder = placeholder
+        self.placeholder_color = placeholder_color
+
+        self.normal_bgcolor = bgcolor
+        self.focused_bgcolor = focused_bgcolor
+        self.hover_bgcolor = hover_bgcolor
+
+        self.border_color = border_color
+        self.focused_border_color = focused_border_color
+        self.cursor_color = cursor_color
+
+        self.on_text_changed = on_text_changed
+        self.on_submit = on_submit
+
+        self.is_focused = False
+        self.cursor_index = len(text)
+        self.cursor_timer = 0
+        self.cursor_visible = True
+
+    @TextLabel.text.setter
+    def text(self, value: str):
+        if self._text != value:
+            self._text = value
+            self._dirty = True
+            self.cursor_index = min(self.cursor_index, len(self._text))
+            if self.on_text_changed:
+                self.on_text_changed(self._text)
+
+    def handle_event(self, event) -> bool:
+        if not self.is_globally_visible:
+            return False
+
+        if super(TextLabel, self).handle_event(event):
+            return True
+
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            was_focused = self.is_focused
+            self.is_focused = self.contains_point(*event.pos)
+
+            if self.is_focused:
+                self.cursor_timer = pygame.time.get_ticks()
+                self.cursor_visible = True
+                if not was_focused:
+                    self.cursor_index = len(self._text)
+                return True
+
+        if self.is_focused and event.type == pygame.KEYDOWN:
+            self.cursor_timer = pygame.time.get_ticks()
+            self.cursor_visible = True
+
+            if event.key == pygame.K_BACKSPACE:
+                if self.cursor_index > 0:
+                    self._text = (
+                        self._text[: self.cursor_index - 1]
+                        + self._text[self.cursor_index :]
+                    )
+                    self.cursor_index -= 1
+                    self._dirty = True
+                    if self.on_text_changed:
+                        self.on_text_changed(self._text)
+
+            elif event.key == pygame.K_DELETE:
+                if self.cursor_index < len(self._text):
+                    self._text = (
+                        self._text[: self.cursor_index]
+                        + self._text[self.cursor_index + 1 :]
+                    )
+                    self._dirty = True
+                    if self.on_text_changed:
+                        self.on_text_changed(self._text)
+
+            elif event.key == pygame.K_LEFT:
+                if self.cursor_index > 0:
+                    self.cursor_index -= 1
+
+            elif event.key == pygame.K_RIGHT:
+                if self.cursor_index < len(self._text):
+                    self.cursor_index += 1
+
+            elif event.key == pygame.K_HOME:
+                self.cursor_index = 0
+
+            elif event.key == pygame.K_END:
+                self.cursor_index = len(self._text)
+
+            elif event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
+                if self.on_submit:
+                    self.on_submit(self._text)
+
+            else:
+                if event.unicode and event.unicode.isprintable():
+                    self._text = (
+                        self._text[: self.cursor_index]
+                        + event.unicode
+                        + self._text[self.cursor_index :]
+                    )
+                    self.cursor_index += len(event.unicode)
+                    self._dirty = True
+                    if self.on_text_changed:
+                        self.on_text_changed(self._text)
+
+            return True
+
+        return False
+
+    def draw_background(self, surface: pygame.Surface):
+        original_bgcolor = self.bgcolor
+        if self.is_focused and self.focused_bgcolor:
+            self.bgcolor = self.focused_bgcolor
+        elif self.is_hovered and self.hover_bgcolor:
+            self.bgcolor = self.hover_bgcolor
+        else:
+            self.bgcolor = self.normal_bgcolor
+
+        super().draw_background(surface)
+        self.bgcolor = original_bgcolor
+
+        b_color = self.focused_border_color if self.is_focused else self.border_color
+        if b_color and self.real_width > 0 and self.real_height > 0:
+            border_rect = (self.real_x, self.real_y, self.real_width, self.real_height)
+            pygame.draw.rect(surface, b_color, border_rect, width=1)
+
+    def draw_foreground(self, surface: pygame.Surface):
+        if not self._text and not self.is_focused and self.placeholder:
+            placeholder_surf = self.font.render(
+                self.placeholder, True, self.placeholder_color
+            )
+            txt_h = placeholder_surf.get_height()
+            draw_y = self.real_y + (self.real_height - txt_h) // 2
+            draw_x = self.real_x + 8
+            surface.blit(placeholder_surf, (draw_x, draw_y))
+            return
+
+        self._render_text()
+        if self.rendered_surface:
+            txt_w, txt_h = self.rendered_surface.get_size()
+            draw_y = self.real_y + (self.real_height - txt_h) // 2
+            
+            left_padding = 8
+            if self.align == "left":
+                draw_x = self.real_x + left_padding
+            elif self.align == "right":
+                draw_x = self.real_x + (self.real_width - txt_w - left_padding)
+            else:
+                draw_x = self.real_x + (self.real_width - txt_w) // 2
+
+            surface.blit(self.rendered_surface, (draw_x, draw_y))
+
+            if self.is_focused:
+                if (pygame.time.get_ticks() - self.cursor_timer) % 1000 < 500:
+                    prefix_text = self._text[: self.cursor_index]
+                    cursor_x_offset = self.font.size(prefix_text)[0]
+                    cursor_x = draw_x + cursor_x_offset
+
+                    cursor_top = draw_y
+                    cursor_bottom = draw_y + txt_h
+                    
+                    pygame.draw.line(
+                        surface,
+                        self.cursor_color,
+                        (cursor_x, cursor_top),
+                        (cursor_x, cursor_bottom),
+                        width=2,
+                    )
+
+
+class ScrollingFrame(Widget):
+    def __init__(
+        self,
+        canvas_width: Dim = None,
+        canvas_height: Dim = None,
+        x: Dim = None,
+        y: Dim = None,
+        width: Dim = None,
+        height: Dim = None,
+        parent=None,
+        bgcolor=(35, 35, 35),
+        background_transparency: float = 0.0,
+        zindex: int = 0,
+        visible: bool = True,
+        scroll_speed: int = 25,
+        show_vertical_scrollbar: bool = True,
+        show_horizontal_scrollbar: bool = False,
+        scrollbar_thickness: int = 10,
+        scrollbar_track_color=(20, 20, 20),
+        scrollbar_thumb_color=(80, 80, 80),
+        scrollbar_hover_color=(120, 120, 120),
+        scrollbar_active_color=(0, 120, 215),
+    ):
+        super().__init__(
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            parent=parent,
+            bgcolor=bgcolor,
+            background_transparency=background_transparency,
+            zindex=zindex,
+            visible=visible,
+        )
+
+        self.canvas_w_dim = canvas_width if canvas_width is not None else Dim(1.0, 0)
+        self.canvas_h_dim = canvas_height if canvas_height is not None else Dim(1.0, 0)
+
+        self.real_canvas_width = 0
+        self.real_canvas_height = 0
+
+        self.scroll_x = 0
+        self.scroll_y = 0
+        self.scroll_speed = scroll_speed
+
+        self.show_vertical_scrollbar = show_vertical_scrollbar
+        self.show_horizontal_scrollbar = show_horizontal_scrollbar
+        self.scrollbar_thickness = scrollbar_thickness
+        self.scrollbar_track_color = scrollbar_track_color
+        self.scrollbar_thumb_color = scrollbar_thumb_color
+        self.scrollbar_hover_color = scrollbar_hover_color
+        self.scrollbar_active_color = scrollbar_active_color
+
+        self._dragging_v_thumb = False
+        self._dragging_h_thumb = False
+        self._drag_start_mouse = (0, 0)
+        self._drag_start_scroll = (0, 0)
+
+        self._v_thumb_hovered = False
+        self._h_thumb_hovered = False
+
+        self.canvas_surface: Optional[pygame.Surface] = None
+
+    def _get_scrollbar_rects(self):
+        v_track, v_thumb = None, None
+        h_track, h_thumb = None, None
+
+        thick = self.scrollbar_thickness
+        max_scroll_x = max(0, self.real_canvas_width - self.real_width)
+        max_scroll_y = max(0, self.real_canvas_height - self.real_height)
+
+        h_offset = thick if self.show_horizontal_scrollbar and max_scroll_x > 0 else 0
+        v_offset = thick if self.show_vertical_scrollbar and max_scroll_y > 0 else 0
+
+        if self.show_vertical_scrollbar and max_scroll_y > 0:
+            track_h = max(1, self.real_height - h_offset)
+            v_track = pygame.Rect(
+                self.real_x + self.real_width - thick, self.real_y, thick, track_h
+            )
+
+            visible_ratio = self.real_height / self.real_canvas_height
+            thumb_h = max(20, int(track_h * visible_ratio))
+            scroll_ratio = self.scroll_y / max_scroll_y
+            thumb_y = v_track.y + int(scroll_ratio * (track_h - thumb_h))
+
+            v_thumb = pygame.Rect(v_track.x, thumb_y, thick, thumb_h)
+
+        if self.show_horizontal_scrollbar and max_scroll_x > 0:
+            track_w = max(1, self.real_width - v_offset)
+            h_track = pygame.Rect(
+                self.real_x, self.real_y + self.real_height - thick, track_w, thick
+            )
+
+            visible_ratio = self.real_width / self.real_canvas_width
+            thumb_w = max(20, int(track_w * visible_ratio))
+            scroll_ratio = self.scroll_x / max_scroll_x
+            thumb_x = h_track.x + int(scroll_ratio * (track_w - thumb_w))
+
+            h_thumb = pygame.Rect(thumb_x, h_track.y, thumb_w, thick)
+
+        return v_track, v_thumb, h_track, h_thumb
+
+    def resolve_layout(self, parent_x: int, parent_y: int, parent_w: int, parent_h: int):
+        self.real_width = self.w_dim.calculate(parent_w)
+        self.real_height = self.h_dim.calculate(parent_h)
+        self.real_x = parent_x + self.x_dim.calculate(parent_w)
+        self.real_y = parent_y + self.y_dim.calculate(parent_h)
+
+        self.real_canvas_width = max(
+            self.real_width, self.canvas_w_dim.calculate(self.real_width)
+        )
+        self.real_canvas_height = max(
+            self.real_height, self.canvas_h_dim.calculate(self.real_height)
+        )
+
+        max_scroll_x = max(0, self.real_canvas_width - self.real_width)
+        max_scroll_y = max(0, self.real_canvas_height - self.real_height)
+        self.scroll_x = max(0, min(self.scroll_x, max_scroll_x))
+        self.scroll_y = max(0, min(self.scroll_y, max_scroll_y))
+
+        if (
+            not self.canvas_surface
+            or self.canvas_surface.get_width() != self.real_canvas_width
+            or self.canvas_surface.get_height() != self.real_canvas_height
+        ):
+            if self.real_canvas_width > 0 and self.real_canvas_height > 0:
+                self.canvas_surface = pygame.Surface(
+                    (self.real_canvas_width, self.real_canvas_height), pygame.SRCALPHA
+                )
+
+        for child in self.children:
+            child.resolve_layout(
+                0, 0, self.real_canvas_width, self.real_canvas_height
+            )
+
+    def handle_event(self, event) -> bool:
+        if not self.is_globally_visible:
+            return False
+
+        v_track, v_thumb, h_track, h_thumb = self._get_scrollbar_rects()
+        max_scroll_x = max(0, self.real_canvas_width - self.real_width)
+        max_scroll_y = max(0, self.real_canvas_height - self.real_height)
+
+        if event.type == pygame.MOUSEMOTION:
+            self.is_hovered = self.contains_point(*event.pos)
+            self._v_thumb_hovered = v_thumb.collidepoint(event.pos) if v_thumb else False
+            self._h_thumb_hovered = h_thumb.collidepoint(event.pos) if h_thumb else False
+
+            if self._dragging_v_thumb and v_track and v_thumb:
+                delta_y = event.pos[1] - self._drag_start_mouse[1]
+                available_track = v_track.height - v_thumb.height
+                if available_track > 0:
+                    scroll_delta = (delta_y / available_track) * max_scroll_y
+                    self.scroll_y = max(
+                        0, min(max_scroll_y, self._drag_start_scroll[1] + scroll_delta)
+                    )
+                return True
+
+            if self._dragging_h_thumb and h_track and h_thumb:
+                delta_x = event.pos[0] - self._drag_start_mouse[0]
+                available_track = h_track.width - h_thumb.width
+                if available_track > 0:
+                    scroll_delta = (delta_x / available_track) * max_scroll_x
+                    self.scroll_x = max(
+                        0, min(max_scroll_x, self._drag_start_scroll[0] + scroll_delta)
+                    )
+                return True
+
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if v_thumb and v_thumb.collidepoint(event.pos):
+                self._dragging_v_thumb = True
+                self._drag_start_mouse = event.pos
+                self._drag_start_scroll = (self.scroll_x, self.scroll_y)
+                return True
+
+            if h_thumb and h_thumb.collidepoint(event.pos):
+                self._dragging_h_thumb = True
+                self._drag_start_mouse = event.pos
+                self._drag_start_scroll = (self.scroll_x, self.scroll_y)
+                return True
+
+            if v_track and v_track.collidepoint(event.pos):
+                click_y = event.pos[1] - v_track.y
+                ratio = click_y / v_track.height
+                self.scroll_y = max(0, min(max_scroll_y, ratio * max_scroll_y))
+                return True
+
+            if h_track and h_track.collidepoint(event.pos):
+                click_x = event.pos[0] - h_track.x
+                ratio = click_x / h_track.width
+                self.scroll_x = max(0, min(max_scroll_x, ratio * max_scroll_x))
+                return True
+
+        if event.type == pygame.MOUSEBUTTONUP and event.button == 1:
+            if self._dragging_v_thumb or self._dragging_h_thumb:
+                self._dragging_v_thumb = False
+                self._dragging_h_thumb = False
+                return True
+
+        if self.is_hovered and event.type == pygame.MOUSEWHEEL:
+            if pygame.key.get_mods() & pygame.KMOD_SHIFT:
+                self.scroll_x = max(
+                    0, min(max_scroll_x, self.scroll_x - event.y * self.scroll_speed)
+                )
+            else:
+                self.scroll_y = max(
+                    0, min(max_scroll_y, self.scroll_y - event.y * self.scroll_speed)
+                )
+            return True
+
+        if hasattr(event, "pos"):
+            px, py = event.pos
+            if not self.contains_point(px, py) and event.type in (
+                pygame.MOUSEBUTTONDOWN,
+                pygame.MOUSEBUTTONUP,
+            ):
+                return False
+
+            canvas_px = px - self.real_x + self.scroll_x
+            canvas_py = py - self.real_y + self.scroll_y
+
+            translated_dict = dict(event.__dict__)
+            translated_dict["pos"] = (canvas_px, canvas_py)
+            translated_event = pygame.event.Event(event.type, translated_dict)
+
+            for child in reversed(self.get_sorted_children()):
+                if child.handle_event(translated_event):
+                    return True
+        else:
+            for child in reversed(self.get_sorted_children()):
+                if child.handle_event(event):
+                    return True
+
+        return False
+
+    def draw_foreground(self, surface: pygame.Surface):
+        v_track, v_thumb, h_track, h_thumb = self._get_scrollbar_rects()
+
+        if v_track and v_thumb:
+            if self.scrollbar_track_color:
+                pygame.draw.rect(surface, self.scrollbar_track_color, v_track)
+
+            if self._dragging_v_thumb:
+                thumb_color = self.scrollbar_active_color
+            elif self._v_thumb_hovered:
+                thumb_color = self.scrollbar_hover_color
+            else:
+                thumb_color = self.scrollbar_thumb_color
+
+            pygame.draw.rect(surface, thumb_color, v_thumb)
+
+        if h_track and h_thumb:
+            if self.scrollbar_track_color:
+                pygame.draw.rect(surface, self.scrollbar_track_color, h_track)
+
+            if self._dragging_h_thumb:
+                thumb_color = self.scrollbar_active_color
+            elif self._h_thumb_hovered:
+                thumb_color = self.scrollbar_hover_color
+            else:
+                thumb_color = self.scrollbar_thumb_color
+
+            pygame.draw.rect(surface, thumb_color, h_thumb)
+
+    def draw(self, surface: pygame.Surface):
+        if not self.is_globally_visible or not self.canvas_surface:
+            return
+
+        self.draw_background(surface)
+
+        self.canvas_surface.fill((0, 0, 0, 0))
+        for child in self.get_sorted_children():
+            child.draw(self.canvas_surface)
+
+        prev_clip = surface.get_clip()
+        frame_rect = pygame.Rect(
+            self.real_x, self.real_y, self.real_width, self.real_height
+        )
+        surface.set_clip(frame_rect.clip(prev_clip))
+
+        visible_area = pygame.Rect(
+            self.scroll_x, self.scroll_y, self.real_width, self.real_height
+        )
+        surface.blit(
+            self.canvas_surface,
+            (self.real_x, self.real_y),
+            area=visible_area,
+        )
+
+        surface.set_clip(prev_clip)
+
+        self.draw_foreground(surface)

nyugui-0.1.0/nyuGUI.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: nyuGUI
+Version: 0.1.0
+Summary: A lightweight GUI library featuring dynamic scale/offset layouting.
+Author: Wjanek13
+Project-URL: Documentation, https://nyugui-documentation.netlify.app
+Requires-Python: >=3.8
+Requires-Dist: pygame>=2.0.0

nyugui-0.1.0/nyuGUI.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+nyuGUI/__init__.py
+nyuGUI/core.py
+nyuGUI/widgets.py
+nyuGUI.egg-info/PKG-INFO
+nyuGUI.egg-info/SOURCES.txt
+nyuGUI.egg-info/dependency_links.txt
+nyuGUI.egg-info/requires.txt
+nyuGUI.egg-info/top_level.txt

nyugui-0.1.0/nyuGUI.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nyugui-0.1.0/nyuGUI.egg-info/requires.txt

@@ -0,0 +1 @@
+pygame>=2.0.0

nyugui-0.1.0/nyuGUI.egg-info/top_level.txt

@@ -0,0 +1 @@
+nyuGUI

nyugui-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nyuGUI"
+version = "0.1.0"
+description = "A lightweight GUI library featuring dynamic scale/offset layouting."
+authors = [{ name = "Wjanek13" }]
+dependencies = [
+    "pygame>=2.0.0"
+]
+requires-python = ">=3.8"
+
+[tool.setuptools.package-data]
+nyugui = ["assets/*.png"]
+
+[project.urls]
+"Documentation" = "https://nyugui-documentation.netlify.app"

nyugui-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+