PGTKernelBasic 0.22.0__py3-none-any.whl

Kernel/KernelEvent.py

@@ -0,0 +1,129 @@
+import pygame
+from functools import partial
+
+from Kernel.KernelWidget import MainScreen
+from Kernel.VFlags import *
+
+
+def _handle_resize(self: "EventDispatcher"):
+    self.screen.blank()
+    for widget in list(reversed(self.screen.child.values())):
+        widget.dispatch_resize()
+def _handle_quit(self: "EventDispatcher"):
+    return False
+mouse_event2flags = {
+    pygame.MOUSEBUTTONUP : {
+        1: Uplclick,
+        2: Upscrollmouse,
+        3: Uprclick,
+        4: Upscrollup,
+        5: Upscrolldown,
+    },
+    pygame.MOUSEBUTTONDOWN : {
+        1 : Downlclick,
+        2 : Downscrollmouse,
+        3 : Downrclick,
+        4 : Downscrollup,
+        5 : Downscrolldown,
+    }
+}
+special_event_to_handle = {
+    pygame.VIDEORESIZE: _handle_resize,
+    pygame.QUIT: _handle_quit,
+}
+def extra_parameter(handler, *args, **kwargs):
+    return partial(handler, *args, **kwargs)
+class EventDispatcher:
+    def __init__(self, screen: MainScreen):
+        self.screen = screen
+        self.current_hovered = None
+        self.event = None
+        self.focused_widget = set()
+        self.pressed_key = set()
+    def event_passdown(self):
+        mouse_pos = pygame.mouse.get_pos()
+        for event in pygame.event.get():
+            self.event = event
+            match event.type:
+                case pygame.MOUSEBUTTONDOWN:
+                    self._dispatch_mousebuttondown(mouse_pos, event)
+                case pygame.MOUSEBUTTONUP:
+                    self._dispatch_mousebuttonup(mouse_pos, event)
+                case pygame.VIDEORESIZE | pygame.QUIT:
+                    result_func = special_event_to_handle[event.type]
+                    is_off = result_func(self)
+                    if is_off is False:
+                        return False
+                case pygame.TEXTINPUT:
+                    for widget in self.focused_widget:
+                        if hasattr(widget, 'process_addchar'):
+                            widget.process_addchar(event.text)
+                case pygame.KEYDOWN:
+                    self.pressed_key.add(event.key)
+                    self._dispatch_key(event)
+                case pygame.KEYUP:
+                    self.pressed_key.discard(event.key)
+        self._dispacth_hover(mouse_pos)
+        return True
+    def _dispatch_key(self, event):
+        match event.key:
+            case pygame.K_BACKSPACE:
+                if event.scancode == 0:
+                    return
+                for widget in self.focused_widget:
+                    if hasattr(widget, 'process_backspace'):
+                        widget.process_backspace()
+    def _dispacth_hover(self, mouse_pos):
+        self.event = None
+        new_hovered = None
+        for widget in list(reversed(self.screen.child.values())):
+            if hasattr(widget, 'is_hovered') and widget.inrect(mouse_pos):
+                new_hovered = widget
+                break
+
+        if new_hovered != self.current_hovered:
+            if self.current_hovered:
+                self.current_hovered.dispatch_release(mouse_pos)()
+                self.current_hovered.is_hovered = False
+
+            if new_hovered:
+                new_hovered.dispatch_hover(mouse_pos)()
+                new_hovered.is_hovered = True
+
+            self.current_hovered = new_hovered
+    def _dispatch_mousebuttondown(self, mouse_pos, event):
+        for widget in list(reversed(self.screen.child.values())):
+            if widget.inrect(mouse_pos):
+                self.screen.focused = False
+                if hasattr(widget, 'dispatch_click'):
+                    func = widget.dispatch_click(mouse_pos, event)
+                    func()
+                return
+        self.screen.focused = True
+    def _dispatch_mousebuttonup(self, mouse_pos, event):
+        if not self.screen.focused:
+            for widget in list(reversed(self.screen.child.values())):
+                if widget.inrect(mouse_pos):
+                    for w in list(self.focused_widget):
+                        w.focused = False
+                    self.focused_widget.clear()
+
+                    widget.focused = True
+                    self.focused_widget.add(widget)
+                    if hasattr(widget, 'process_addchar'):
+                        pygame.key.start_text_input()
+                    else:
+                        pygame.key.stop_text_input()
+                    if hasattr(widget, 'dispatch_click'):
+                        func = widget.dispatch_click(mouse_pos, event)
+                        func()
+
+                    return
+        else:
+            for w in list(self.focused_widget):
+                w.focused = False
+                if hasattr(w, 'process_addchar'):
+                    pygame.key.stop_text_input()
+            self.focused_widget.clear()
+    def is_key_pressed(self, key_code):
+        return key_code in self.pressed_key

Kernel/KernelLayout.py

@@ -0,0 +1,58 @@
+from Kernel.KernelWidget import Widget, ImmutableRect
+from Kernel.ObjType import PosTuple
+
+
+class GridLayout:
+    def __init__(self, width_grid: int, height_grid: int, size: PosTuple, pos: PosTuple | None = None, padding=20):
+        self.width_grid = width_grid
+        self.height_grid = height_grid
+        self.total_width, self.total_height = size
+        self.pos = pos if pos is not None else (0, 0)
+        self.padding = padding
+
+        available_width = self.total_width - (2 * padding)
+        available_height = self.total_height - (2 * padding)
+
+        self.cell_width = available_width / width_grid
+        self.cell_height = available_height / height_grid
+        self.edge_cell = (self.cell_width, self.cell_height)
+
+        self.cells = []
+
+        cur_pos_x = self.pos[0] + padding
+
+        for i in range(width_grid):
+            row_cells = []
+            cur_pos_y = self.pos[1] + padding
+
+            for j in range(height_grid):
+                cell = (cur_pos_x, cur_pos_y)
+                row_cells.append(cell)
+                cur_pos_y += self.cell_height
+
+            self.cells.append(row_cells)
+            cur_pos_x += self.cell_width
+
+    def setpos(self, widget: Widget, cell_pos=tuple[int, int], center = True):
+        xpos, ypos = cell_pos
+        cell_x, cell_y = self.cells[xpos][ypos]
+        w, h = widget.rect.w, widget.rect.h
+
+        if center:
+            final_x = cell_x + (self.cell_width - w) / 2
+            final_y = cell_y + (self.cell_height - h) / 2
+        else:
+            final_x = cell_x
+            final_y = cell_y
+        if isinstance(widget.rect, ImmutableRect):
+            widget.rect = ImmutableRect(final_x, final_y, w, h)
+        else:
+            widget.rect.x = final_x
+            widget.rect.y = final_y
+
+class HorizontalLayout(GridLayout):
+    def __init__(self, length : int, size: PosTuple, pos : PosTuple, padding=20):
+        super().__init__(length, 1, size, pos, padding)
+class VerticalLayout(GridLayout):
+    def __init__(self, length: int, size: PosTuple, pos: PosTuple, padding=20):
+        super().__init__(1, length, size, pos, padding)

Kernel/KernelPosition.py

@@ -0,0 +1,231 @@
+#Kernel 1(build 0.09)
+#Pre-alpha
+from typing import Tuple, Optional
+from Kernel.KernalInit import init
+from Kernel.ObjType import PosTuple, RectTuple
+init()
+#####
+#Margin
+#####
+class Anchor:
+     topleft = 'TopLeft'
+     topcenter = 'TopCenter'
+     topright = 'TopRight'
+     centerleft = 'CenterLeft'
+     center = 'Center'
+     centerright = 'CenterRight'
+     bottomleft = 'BottomLeft'
+     bottomcenter = 'BottomCenter'
+     bottomright = 'BottomRight'
+class Margin:
+    """
+    Manages margins and the display position of objects on the screen.
+    This class supports:
+    - Calculating padding based on percentage or absolute value.
+    - Storing default anchors to position objects.
+    - Caching calculated position results to improve performance.
+    - Updating when the screen size changes.
+    - Returning the content area (content_rect) after padding is subtracted.
+    Attributes
+    width_screen : int
+    Current screen width.
+    height_screen : int
+    Current screen height.
+    padding : tuple[float, float]
+    Padding by pixels (x, y).
+    percentage : tuple[float, float]
+    Padding by percentage (0–100).
+    cache : dict
+    Stores default anchors.
+    cache_pos : dict
+    Caches the calculated position for the object.
+    Methods:
+    get_pos(obj, anchor):
+    Calculates the (x, y) position of the object based on the anchor.
+    Save_margin(anchor):
+    Saves the default anchor for later use.
+    Update_on_resize(screen):
+    Updates screen size and padding when resizing.
+    content_rect:
+    Returns the remaining content area after subtracting padding.
+    """
+    __slots__ = ('width_screen', 'height_screen', 'last_screen_size', 'padding', 'percentage', 'cache', 'cache_pos')
+    def __init__(self, screen, percentage_padding: PosTuple | None = None, padding: PosTuple | None = (0, 0)):
+        self.width_screen, self.height_screen = screen.get_size()
+        self.percentage = percentage_padding
+        if self.percentage:
+            if 0 < percentage_padding[0] > 100 or 0 < percentage_padding[1] > 100:
+                raise ValueError('Your padding must in range from 0 to 100')
+            self.padding = (self.width_screen * self.percentage[0] / 100, self.height_screen * self.percentage[1] / 100)
+        self.padding = padding
+        self.cache = {}
+        self.cache_pos = {}
+    def update_padding(self, new_padding):
+        self.padding = new_padding
+    def get_pos(self, obj: PosTuple, anchor: str | None):
+        if not anchor:
+            if 'Anchor' in self.cache:
+                anchor = self.cache['Anchor']
+
+        w_o, h_o = obj
+        if (w_o, h_o, anchor) in self.cache_pos:
+            return self.cache_pos[(w_o, h_o, anchor)]
+
+        w_s, h_s = self.width_screen, self.height_screen
+        b_x, b_y = self.padding
+        left = b_x
+        center_x = (w_s - w_o) // 2
+        right = w_s - w_o - b_x
+        top = b_y
+        center_y = (h_s - h_o) // 2
+        bottom = h_s - h_o - b_y
+        match anchor:
+            case 'TopLeft':
+                pos = (left, top)
+            case 'TopCenter':
+                pos = (center_x, top)
+            case 'TopRight':
+                pos = (right, top)
+            case 'CenterLeft':
+                pos = (left, center_y)
+            case 'Center':
+                pos = (center_x, center_y)
+            case 'CenterRight':
+                pos = (right, center_y)
+            case 'BottomLeft':
+                pos = (left, bottom)
+            case 'BottomCenter':
+                pos = (center_x, bottom)
+            case 'BottomRight':
+                pos = (right, bottom)
+            case _:  # Trường hợp mặc định (tương đương else)
+                raise KeyError(f'Invalid anchor: {anchor}')
+
+        self.cache_pos[(w_o, h_o, anchor)] = pos
+        return pos
+    def save_margin(self, anchor: str):
+        if anchor in {
+            'CenterRight': 0,
+            'Center': 0,
+            'CenterLeft' : 0,
+            'TopCenter': 0,
+            'TopLeft' : 0,
+            'TopRight': 0,
+            'BottomCenter': 0,
+            'BottomLeft': 0,
+            'BottomRight': 0
+        }:
+            self.cache['Anchor'] = anchor
+        else:
+            raise KeyError(f'Invalid anchor: {anchor}')
+    def update_on_resize(self, screen):
+        self.width_screen, self.height_screen = screen.get_size()
+        if self.percentage:
+            self.padding = (self.width_screen * self.percentage[0] / 100,
+                            self.height_screen * self.percentage[1] / 100)
+        self.cache_pos.clear()
+
+    @property
+    def content_rect(self):
+        left, top = self.padding
+        width = self.width_screen - 2 * self.padding[0]
+        height = self.height_screen - 2 * self.padding[1]
+        width = max(0, width)
+        height = max(0, height)
+        return left, top, width, height
+
+######
+#NEXT
+######
+class LayoutHelper:
+    """
+    Docstring for LayoutHelper:
+    A utility class to calculate the position of a new object relative to an existing object's rectangle.
+    It supports positioning in four directions: 'Right', 'Left', 'Down', and 'Up', with optional padding.
+    Attributes:
+    screen_w : int
+        Current screen width.
+    screen_h : int
+        Current screen height.
+    Methods:
+    update_screen(screen):
+        Updates the stored screen dimensions.
+    Get_pos(obj_rect, next_obj_size, direction, padding=(0, 0)):
+        Calculates the position for the new object based on the specified direction and padding.
+    Getpos_up(obj_rect, next_obj_size, padding=(0, 0)):
+        Calculates the position above the existing object.
+    Getpos_down(obj_rect, next_obj_size, padding=(0, 0)):
+        Calculates the position below the existing object.
+    Getpos_right(obj_rect, next_obj_size, padding=(0, 0)):
+        Calculates the position to the right of the existing object.
+    Getpos_left(obj_rect, next_obj_size, padding=(0, 0)):
+        Calculates the position to the left of the existing object.
+    """
+    __slots__ = ('screen_w', 'screen_h')
+    def __init__(self, screen):
+        self.screen_w, self.screen_h = screen.get_size()
+    def update_screen(self, screen):
+        self.screen_w, self.screen_h = screen.get_size()
+
+    def get_pos(self, obj_rect: RectTuple, next_obj_size: PosTuple, direction, padding=(0, 0)) -> tuple[float, float]:
+        ox, oy, ow, oh = obj_rect
+        nw, nh = next_obj_size
+        px, py = padding
+        sw, sh = self.screen_w, self.screen_h
+
+        match direction:
+            case 'Right':
+                x, y = ox + ow + px, oy + py
+            case 'Left':
+                x, y = ox - px - nw, oy + py
+            case 'Down':
+                x, y = ox + px, oy + oh + py
+            case 'Up':
+                x, y = ox + px, oy - py - nh
+            case _:
+                raise KeyError('Invalid direction')
+
+        if x < 0 or y < 0 or (x + nw > sw) or (y + nh > sh):
+            raise ValueError('Out of screen')
+
+        return x, y
+    def getpos_up(self, obj_rect: RectTuple, next_obj_size: PosTuple, padding=(0, 0))-> tuple[float, float]:
+        ox, oy, ow, oh = obj_rect
+        nw, nh = next_obj_size
+        px, py = padding
+        sw, sh = self.screen_w, self.screen_h
+        x = ox + px
+        y = oy - py - nh
+        if y < 0 or x > sw - nw or x < 0:
+            raise ValueError('Out of screen')
+        return x, y
+    def getpos_down(self, obj_rect: RectTuple, next_obj_size: PosTuple, padding=(0, 0))-> tuple[float, float]:
+        ox, oy, ow, oh = obj_rect
+        nw, nh = next_obj_size
+        px, py = padding
+        sw, sh = self.screen_w, self.screen_h
+        x = ox + px
+        y = oy + oh + py
+        if y > sh - nh or x > sw - nw or x < 0:
+            raise ValueError('Out of screen')
+        return x, y
+    def getpos_right(self, obj_rect: RectTuple, next_obj_size: PosTuple, padding=(0, 0))-> tuple[float, float]:
+        ox, oy, ow, oh = obj_rect
+        nw, nh = next_obj_size
+        px, py = padding
+        sw, sh = self.screen_w, self.screen_h
+        x = ox + ow + px
+        y = oy + py
+        if x + nw > sw or y + nh > sh or y < 0:
+            raise ValueError('Out of screen')
+        return x, y
+    def getpos_left(self, obj_rect: RectTuple, next_obj_size: PosTuple, padding=(0, 0))-> tuple[float, float]:
+        ox, oy, ow, oh = obj_rect
+        nw, nh = next_obj_size
+        px, py = padding
+        sw, sh = self.screen_w, self.screen_h
+        x = ox - px - nw
+        y = oy + py
+        if x < 0 or y > sh - nh or y < 0:
+            raise ValueError('Out of screen')
+        return x, y

Kernel/KernelRun.py

@@ -0,0 +1,81 @@
+from typing import Union
+
+from collections.abc import Callable
+import concurrent.futures
+import pygame
+
+from Kernel import PygameRender, MainScreen, EventDispatcher
+
+quitnow = pygame.QUIT
+class BreakThread(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+class Thread:
+    def __init__(self, screen: MainScreen, functions: list,
+                 quitcondition: int | Callable[..., bool] | None = pygame.QUIT, fps: int| float=60):
+        self.functions = functions
+        self.quitcondition = quitcondition
+        self.running = True
+        self.fps = fps
+        self.clock = pygame.time.Clock()
+        self.break_requested = False
+        self.event_manager = EventDispatcher(screen)
+        self.dt = 1.0 / fps if fps > 0 else 0.016
+    def _loop_start(self):
+        while self.running and not self.break_requested:
+            self.dt = self.clock.tick(self.fps) / 1000.0
+            if self.quitcondition == pygame.QUIT:
+                self.running = self.event_manager.event_passdown()
+            if callable(self.quitcondition) and self.quitcondition():
+                self.running = False
+            for func in self.functions:
+                func()
+    def threadstart(self):
+        if self.quitcondition is not None or self.fps > 0:
+            try:
+                self._loop_start()
+            except BreakThread:
+                self.running = False
+        else:
+            for func in self.functions:
+                func()
+            self.running = False
+    def threadbreak(self):
+        self.break_requested = True
+    def immediate_break(self):
+        self.running = False
+    def run_parallel(self, cpu_func, *args):
+        with concurrent.futures.ProcessPoolExecutor() as executor:
+            future = executor.submit(cpu_func, *args)
+            return future
+    def check_future(self, future):
+        if future.done():
+            return future.result()
+        return None
+    def get_event(self):
+        return self.event_manager.event
+class MainApplication(Thread):
+    def __init__(self, screen_size, screen_flags=0, screen_bg = (0,0,0),
+                 fixed = False, quitcondition: int | Callable[..., bool] | None = quitnow,
+                 fps: int | float=60, render_engine = PygameRender, caption = None, functions = None):
+        user_functions = functions if functions is not None else []
+        screen = MainScreen(screen_size, screen_flags, screen_bg, fixed)
+        screen.set_common_engine(render_engine)
+        if caption:
+            screen.set_caption(caption)
+        super().__init__(screen, user_functions, quitcondition, fps)
+        self.screen = screen
+        self.functions.append(self._main_render)
+    def _main_render(self):
+        for widget in self.screen.child.values():
+            widget.render()
+            if widget.child:
+                self._recursive_render(widget)
+        pygame.display.flip()
+    def add_action(self, func):
+        self.functions.append(func)
+    def _recursive_render(self, parent_widget):
+        for widget in parent_widget.child.values():
+            widget.render()
+            if widget.child:
+                self._recursive_render(widget)