PGTKernelbasic 0.23.0__py3-none-any.whl

Kernel/KernelWidget.py

@@ -0,0 +1,353 @@
+from typing import Tuple, Union, Dict
+from dataclasses import dataclass
+import pygame
+from Kernel.KernelPosition import Margin
+from Kernel.ObjType import PosTuple, RectTuple
+from Kernel.RFlags import *
+from Kernel.KernalInit import init
+init()
+def trashfunc(*args, **kwargs):
+    pass
+def valid_background(bg):
+    """
+    Check if it is a valid background
+    """
+    if isinstance(bg, pygame.Surface) or (
+            isinstance(bg, tuple) and len(bg) in (3, 4) and all(isinstance(x, (int, float)) for x in bg)):
+        return True
+    else:
+        return False
+"""
+ImmutableRect and MutableRect:
+the base object for any widget class as bar, button coming soon in this tool
+x, y: the pos of rect
+w, h: the width and the height of this rect
+"""
+@dataclass(frozen=True)
+class ImmutableRect:
+    __slots__ = ('x', 'y', 'w', 'h')
+    x:int | float
+    y:int |float
+    w:int | float
+    h:int |float
+@dataclass
+class MutableRect:
+    __slots__ = ('x', 'y', 'w', 'h')
+    x:int | float
+    y:int |float
+    w:int | float
+    h:int |float
+
+
+class Widget:
+    """
+
+    """
+    __slots__ = ('parent' ,'rect', 'name', 'is_dirty', 'uflags', 'vflags', 'dirty_uflags',
+                 'dirty_vflags', 'dirty_auto_flag','pos_x', 'pos_y', 'child',
+                 'margin_manager', 'anchor', 'render_engine', 'render_engine_type', 'focused')
+    def __init__(self, parent: Union["MainScreen", "Widget"], rect: RectTuple | PosTuple,
+                 can_change = False, name: str | None = None):
+        if len(rect) == 2:
+            w, h = rect
+            rect = (0, 0, w, h)
+        else:
+            if isinstance(parent, Widget):
+                x,y,w,h = rect
+                rect = (x + parent.rect.x, y +parent.rect.y, w, h)
+        self.rect = ImmutableRect(*rect) if not can_change else MutableRect(*rect)
+        self.parent = parent
+        self.name = name if name else str(id(self))
+        self.uflags = set()
+        self.vflags = {}
+        self.dirty_uflags = set()
+        self.dirty_vflags = set()
+        self.dirty_auto_flag = set()
+        self.pos_x = []
+        self.pos_y = []
+        self.child: dict[str, "Widget"] = {}
+        if isinstance(parent, (MainScreen, Widget)):
+            parent.child[self.name] = self
+        if isinstance(parent, Widget):
+            self.parent.pos_x.append(rect[0])
+            self.parent.pos_y.append(rect[1])
+        self.margin_manager: None | Margin = None
+        self.anchor = None
+        self.render_engine_type = self.parent.render_engine_type
+        if self.parent.render_engine_type:
+            self.render_engine = self.parent.render_engine_type(self)
+        else:
+            self.render_engine = None
+        self.focused = True
+    def set_render_engine(self, engine):
+        self.render_engine = engine(self)
+    def render(self):
+        self.render_engine.render()
+    def get_background(self):
+        if isinstance(self.parent, Widget):
+            if bg_widget in self.parent.vflags:
+                return self.parent.vflags[bg_widget]
+            return self.parent.get_background()
+        elif isinstance(self.parent, MainScreen):
+            return self.parent.background
+        else:
+            raise ValueError("Your widget parent must be the widget, pygame.Surface or MainScreen class")
+    def get_rect(self) -> pygame.Rect:
+        return pygame.Rect(self.rect.x, self.rect.y, self.rect.w, self.rect.h)
+    def get_pos(self):
+        return self.rect.x, self.rect.y
+    def get_size(self):
+        return self.rect.w, self.rect.h
+    def get_surface(self):
+        if isinstance(self.parent, pygame.Surface):
+            return self.parent
+        elif isinstance(self.parent, MainScreen):
+            return self.parent.surface
+        else:
+            return self.parent.get_surface()
+    def destroy(self):
+        self.hide_itself()
+        if isinstance(self.parent, Widget):
+            for name, child in self.parent.child.items():
+                if child is self:
+                    del self.parent.child[name]
+                    break
+        self.parent = None
+        self.child.clear()
+    def hide_itself(self):
+        bg = self.get_background()
+        if isinstance(bg, tuple):
+            surface = self.get_surface()
+            pygame.draw.rect(surface, bg, (self.rect.x,self.rect.y, self.rect.w, self.rect.h))
+        elif isinstance(bg, pygame.Surface):
+            surface = self.get_surface()
+            surface.blit(bg, (0,0), (self.rect.x,self.rect.y, self.rect.w, self.rect.h))
+    def change_rect(self, rect: RectTuple):
+        self.change_pos((rect[0], rect[1]))
+        self.change_size((rect[2], rect[3]))
+    def change_pos(self, new_pos: PosTuple):
+        self.rerender()
+        if isinstance(self.rect, MutableRect):
+            self.rect.x, self.rect.y = new_pos
+            convert_a_lot(self)
+        else:
+            raise TypeError('Your widget pos and size is immutable')
+    def change_size(self, new_size: PosTuple):
+        self.rerender()
+        if isinstance(self.rect, MutableRect):
+            self.rect.w, self.rect.h = new_size
+        else:
+            raise TypeError('Your widget pos and size is immutable')
+    def rerender(self):
+        self.dirty_vflags.update(self.vflags.keys())
+        self.dirty_uflags.update(self.uflags)
+        for chd in self.child.values():
+            chd.rerender()
+        self.hide_itself()
+    def inrect(self, pos: PosTuple):
+        px, py = pos
+        return (self.rect.x <= px <= self.rect.x + self.rect.w) and (self.rect.y <= py <= self.rect.y + self.rect.h)
+    def replace_itself(self, new_widget: "Widget"):
+        self.name = new_widget.name
+        self.uflags = new_widget.uflags.copy()
+        self.dirty_uflags = new_widget.dirty_uflags.copy()
+        self.vflags = new_widget.vflags.copy()
+        self.dirty_vflags = new_widget.dirty_vflags.copy()
+        self.dirty_auto_flag = new_widget.dirty_auto_flag
+        self.parent.child[self.name] = new_widget
+        self.pos_x = new_widget.pos_x
+        self.pos_y = new_widget.pos_y
+        self.child = new_widget.child
+        self.rerender()
+    def set_margin(self, anchor, percentage_padding: None | PosTuple = None, padding: None | PosTuple = (0, 0)):
+        self.margin_manager = Margin(self.parent, percentage_padding, padding)
+        if self.margin_manager:
+            pos_x, pos_y = self.margin_manager.get_pos(self.get_size(), anchor)
+            if isinstance(self.parent, Widget):
+                pos_x += self.parent.rect.x
+                pos_y += self.parent.rect.y
+            if isinstance(self.rect, ImmutableRect):
+                self.rect = ImmutableRect(pos_x, pos_y, self.rect.w, self.rect.h)
+            else:
+                self.rect.x = pos_x
+                self.rect.y = pos_y
+        self.anchor = anchor
+    def anchor_to_pos(self, anchor: str):
+        if self.margin_manager:
+            pos_x, pos_y = self.margin_manager.get_pos(self.get_size(), anchor)
+            if isinstance(self.parent, Widget):
+                pos_x += self.parent.rect.x
+                pos_y += self.parent.rect.y
+            if isinstance(self.rect, ImmutableRect):
+                self.rect = ImmutableRect(pos_x, pos_y, self.rect.w, self.rect.h)
+            else:
+                self.rect.x = pos_x
+                self.rect.y = pos_y
+        self.anchor = anchor
+    def set_flags(self, uflags: tuple=(), vflags: tuple[tuple]=(())):
+        for uflag in uflags:
+            self.uflags.add(uflag)
+            self.dirty_uflags.add(uflag)
+        for pack in vflags:
+            self.vflags[pack[0]] = pack[1]
+            self.dirty_vflags.add(pack[0])
+    def add_uflag(self, *uflags):
+        for uflag in uflags:
+            self.uflags.add(uflag)
+            self.dirty_uflags.add(uflag)
+    def add_vflag(self, *flagpacks):
+        for flagpack in flagpacks:
+            vflag, val = flagpack
+            self.vflags[vflag] = val
+            self.dirty_vflags.add(vflag)
+    def change_uflag(self, oldflag, newflag):
+        try:
+            self.uflags.remove(oldflag)
+            self.uflags.add(newflag)
+            self.dirty_uflags.add(newflag)
+        except:
+            raise KeyError(f'flag: {oldflag} is not found to change')
+    def change_vflag(self, flag, newval):
+        try:
+            self.vflags[flag] = newval
+            self.dirty_vflags.add(flag)
+        except:
+            raise KeyError(f'flag: {flag} is not found to change')
+    def remove_uflag(self, flag):
+        try:
+            rflag = rflags_to_uflags[flag]
+            self.uflags.remove(flag)
+            self.dirty_vflags.add(rflag)
+        except KeyError:
+            raise KeyError(f'flag: {flag} is not found to change')
+    def remove_vflag(self, flag):
+        try:
+            rflag = rflags_to_vflags[flag]
+            del self.vflags[flag]
+            self.dirty_vflags.add(rflag)
+        except:
+            raise KeyError(f'flag: {flag} is not found to change')
+    def blank_flag(self):
+        self.uflags = set()
+        self.vflags = {}
+        self.dirty_uflags = set()
+        self.dirty_vflags = set()
+    def dispatch_resize(self):
+        if self.margin_manager:
+            self.margin_manager.update_on_resize(self.parent)
+            if self.anchor:
+                self.anchor_to_pos(self.anchor)
+            else:
+                print(f"Warning: Widget {self.name} has margin but no anchor.")
+            self.rerender()
+        else:
+            self.rerender()
+        for child in self.child.values():
+            child.dispatch_resize()
+    def dispatch_click(self, *args):
+        return trashfunc
+    def dispatch_release(self, *args):
+        return trashfunc
+    def dispatch_hover(self, *args):
+        return trashfunc
+def convert(pos, offset):
+    return pos[0] + offset[0], pos[1] + offset[1]
+def convert_a_lot(widget: Widget):
+    offset_x, offset_y = widget.rect.x, widget.rect.y
+    new_x = [val + offset_x for val in widget.pos_x]
+    new_y = [val + offset_y for val in widget.pos_y]
+    return new_x, new_y
+class MainScreen:
+    """
+    """
+    def __init__(self, size, flags=0, bg = (0,0,0), fixed = False):
+        if fixed:
+            self.surface = pygame.display.set_mode(size, flags)
+        else:
+            self.surface = pygame.display.set_mode(size, pygame.RESIZABLE | flags)
+        if valid_background(bg):
+            self.background = bg
+        self.child = {}
+        self.margin_manager = None
+        self.blank(bg)
+        self.render_engine_type = None
+        self.focused = False
+    def get_size(self):
+        return self.surface.get_size()
+    def set_margin(self, border_percent: PosTuple | None, padding):
+        from Kernel.KernelPosition import Margin
+        self.margin_manager = Margin(self.surface, border_percent, padding)
+    def set_caption(self, caption: str):
+        pygame.display.set_caption(caption)
+    def blank(self, new_bg=None):
+        if not new_bg:
+            if not isinstance(self.background, pygame.Surface):
+                self.surface.fill(self.background)
+            else:
+                self.blit(self.background, (0,0))
+        else:
+            if not isinstance(new_bg, pygame.Surface):
+                self.surface.fill(new_bg)
+            else:
+                self.blit(new_bg, (0,0))
+    def blit(self, source, dest):
+        self.surface.blit(source, dest)
+    def blit_to_anchor(self,surface, anchor: str):
+        if self.margin_manager:
+            pos = self.margin_manager.get_pos(surface.get_size(), anchor)
+            self.surface.blit(surface, pos)
+        else:
+            raise ValueError("you must set the margin manager after blit to anchor")
+    def addWidget(self, widget: Widget, widget_id):
+        self.child[widget_id] = widget
+    def delWidget(self, widget_id):
+        del self.child[widget_id]
+    def getWidget(self, widget_id: str) -> Widget:
+        return self.child.get(widget_id)
+    def clearWidget(self):
+        for widget in self.child.values():
+            widget.destroy()
+        self.child.clear()
+    def set_common_engine(self, engine):
+        self.render_engine_type = engine
+    def flip(self):
+        pygame.display.flip()
+class PygameRender:
+    """
+
+    """
+    def __init__(self, widget: Widget):
+        self.widget = widget
+        if isinstance(self.widget.parent, Widget):
+            self.bg = self.widget.parent.get_background()
+        elif isinstance(self.widget.parent, MainScreen):
+            self.bg = self.widget.parent.background
+        else:
+            raise ValueError("Your widget parent must be the widget, pygame.Surface or MainScreen class")
+    def render(self):
+        from Kernel.PgRenderCompo.LinkRenderfunc import renderfunc
+        try:
+            if len(self.widget.uflags) == 0 and len(self.widget.vflags) == 0:
+                self.widget.hide_itself()
+            else:
+                for flag in self.widget.dirty_uflags:
+                    renderfunc[flag](self.widget)
+                for flag in self.widget.dirty_vflags:
+                    renderfunc[flag](self.widget, self.widget.get_surface())
+                for flag in self.widget.dirty_auto_flag:
+                    try:
+                        renderfunc[flag](self.widget, self.widget.get_surface())
+                    except TypeError:
+                        renderfunc[flag](self.widget)
+            self.widget.dirty_vflags.clear()
+            self.widget.dirty_uflags.clear()
+            self.widget.dirty_auto_flag.clear()
+        except KeyError as e:
+            raise ValueError(f"Flag {e} not found in renderfunc mapping. Check LinkRenderfunc.py")
+class SkiaRender:
+    def __init__(self, widget: Widget):
+        self.widget = widget
+    #coming soon
+class UltraRender:
+    def __init__(self):
+        print('Render with OpenGL coming soon in kernel 2.0')

Kernel/ObjType.py

@@ -0,0 +1,14 @@
+from collections import namedtuple
+RectTuple = tuple[int | float,int | float,int | float,int | float]
+PosTuple = tuple[int | float,int | float]
+class Border:
+    def __init__(self, border_width, border_color):
+        self.border_width = border_width
+        self.border_col = border_color
+class TextPack:
+    __slots__ = ('Color', 'Font', 'Size', 'Text')
+    def __init__(self, Color, Font, Size, Text):
+        self.Color = Color
+        self.Font = Font
+        self.Size = Size
+        self.Text = Text

Kernel/PgRenderCompo/ButtonObj.py

@@ -0,0 +1,192 @@
+from Kernel import Widget, valid_background
+from Kernel.VFlags import *
+from Kernel.ObjType import RectTuple, PosTuple
+import pygame
+from collections import deque
+def trashfunc(*args, **kwargs):
+    pass
+class FixedButton(Widget):
+    def __init__(self, parent, rect: RectTuple | PosTuple, bg=None, hoverbg=None, pressbg=None,name: str| None = None):
+        super().__init__(parent, rect=rect, name=name)
+        self.is_hovered = False
+        self.lock_hover = False
+        if valid_background(bg):
+            self.add_vflag((bg_widget, bg))
+        self.bg = bg
+        if valid_background(hoverbg):
+            self.add_vflag((hover_bg, hoverbg))
+        if valid_background(pressbg):
+            self.add_vflag((pressed_bg, pressbg))
+    def set_hoverbg(self, hoverbg):
+        if valid_background(hoverbg):
+            self.add_vflag((hover_bg, hoverbg))
+    def set_pressbg(self, pressbg):
+        if valid_background(pressbg):
+            self.add_vflag((press_bg, pressbg))
+    def set_disablebg(self, disablebg):
+        if valid_background(disablebg):
+            self.add_vflag((disable_bg, disablebg))
+
+    def dispatch_click(self, mouse_pos, event):
+        #dispatch recursion
+        result_func = trashfunc
+        from Kernel.KernelEvent import mouse_event2flags
+        for widget in list(reversed(self.child.values())):
+            if widget.inrect(mouse_pos):
+                func = widget.dispatch_click(mouse_pos, event)
+                result_func = func
+
+        if self.inrect(mouse_pos):
+            self.handle_click_event(event)
+
+            flag = mouse_event2flags.get(event.type, {}).get(event.button)
+            return self._get_handler(flag)
+
+        return result_func
+
+    def handle_click_event(self, event):
+        if pressed_bg in self.vflags:
+            if event.type == pygame.MOUSEBUTTONDOWN:
+                self.vflags[bg_widget] = self.vflags[pressed_bg]
+                self.lock_hover = True
+                self.rerender()
+            elif event.type == pygame.MOUSEBUTTONUP:
+                self.lock_hover = False
+                self.add_vflag((bg_widget, self.bg))
+                self.rerender()
+
+    def _get_handler(self, flag):
+        handler = self.vflags.get(flag, trashfunc)
+        if handler == trashfunc:
+            return trashfunc
+
+        import inspect
+        param_count = len(inspect.signature(handler).parameters)
+
+        if param_count == 0:
+            return lambda: handler()
+        else:
+            return lambda: handler(self)
+
+    def handle_realease_visual(self):
+        self.vflags[bg_widget] = self.bg
+        self.lock_hover = False
+        self.rerender()
+    def dispatch_hover(self, mouse_pos):
+        result_func = trashfunc
+        if not hasattr(self, 'text'):
+             pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_HAND)
+        for widget in list(reversed(self.child.values())):
+            if widget.inrect(mouse_pos):
+                func = widget.dispatch_hover(mouse_pos)
+                result_func = func
+        if self.inrect(mouse_pos):
+            if hover_bg in self.vflags:
+                if not self.lock_hover:
+                    self.add_vflag((bg_widget, self.vflags[hover_bg]))
+                    self.rerender()
+            return self._get_handler(Hoverfunc)
+        return result_func
+    def dispatch_release(self, mouse_pos):
+        result_func = trashfunc
+        if not hasattr(self, 'text'):
+             pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_ARROW)
+        for widget in list(reversed(self.child.values())):
+            if not widget.inrect(mouse_pos):
+                func = widget.dispatch_release(mouse_pos)
+                result_func = func
+        if not self.inrect(mouse_pos):
+            self.handle_realease_visual()
+            return self._get_handler(Realeasefunc)
+        return result_func
+
+
+class ToggleButton(FixedButton):
+    def __init__(self, parent, rect,name: str| None = None, fbg=None, tbg=None, hoverbg=None, lock_toogle=False):
+        super().__init__(parent, rect, fbg, hoverbg, tbg, name=name)
+        self.lock_toogle = lock_toogle
+        self.state = False
+        self.group = None
+
+    def handle_click_event(self, event):
+        if self.lock_toogle: return
+        match event.type:
+            case pygame.MOUSEBUTTONDOWN:
+                next_visual = not self.state
+                self.vflags[bg_widget] = self.vflags[pressed_bg] if next_visual else self.bg
+                self.lock_hover = True
+                self.rerender()
+            case pygame.MOUSEBUTTONUP:
+                if self.group:
+                    if not self.state:
+                        self.state = self.group.handle_request_on(self)
+                    else:
+                        self.state = False
+                        self.group.handle_request_off(self)
+                else:
+                    self.state = not self.state
+
+                self.lock_hover = self.state
+                self.vflags[bg_widget] = self.vflags[pressed_bg] if self.state else self.bg
+                self.rerender()
+
+    def handle_realease_visual(self):
+        if self.state:
+            self.vflags[bg_widget] = self.vflags.get(pressed_bg, self.bg)
+            self.lock_hover = True
+        else:
+            self.vflags[bg_widget] = self.bg
+            self.lock_hover = False
+        self.rerender()
+
+
+class ToogleGroup:
+    def __init__(self, group: list = None, max_button=1):
+        self.group = group if group else []
+        self.on_group = deque()
+        self.max_button = max_button
+
+        if self.group:
+            for btn in self.group:
+                btn.group = self
+
+    def add(self, tooglebutton: ToggleButton):
+        self.group.append(tooglebutton)
+        tooglebutton.group = self
+
+    def remove(self, tooglebutton: ToggleButton):
+        if tooglebutton in self.group:
+            self.group.remove(tooglebutton)
+            tooglebutton.group = None
+            if tooglebutton in self.on_group:
+                self.on_group.remove(tooglebutton)
+
+    def handle_request_on(self, btn) -> bool:
+        if btn not in self.on_group:
+            self.on_group.append(btn)
+        while len(self.on_group) > self.max_button:
+            oldest_btn = self.on_group.popleft()
+            oldest_btn.state = False
+            oldest_btn.handle_realease_visual()
+
+        return True  # Cho phép bật
+
+    def handle_request_off(self, btn):
+        if btn in self.on_group:
+            self.on_group.remove(btn)
+
+    def clear(self, turn_off: bool = False):
+        for btn in self.group:
+            btn.group = None
+            if turn_off:
+                btn.state = False
+                btn.handle_realease_visual()
+        self.group.clear()
+        self.on_group.clear()
+
+    def change_max(self, new_max: int):
+        self.max_button = new_max
+        while len(self.on_group) > self.max_button:
+            btn = self.on_group.popleft()
+            btn.state = False
+            btn.handle_realease_visual()

Kernel/PgRenderCompo/LinkRenderfunc.py

@@ -0,0 +1,71 @@
+from Kernel.PgRenderCompo.RRender import *
+from Kernel.RFlags import *
+def notingfunc(*args, **kwargs):
+    pass
+renderfunc = {
+    ###########
+    #UFLAG
+    ###########
+    text_Is_Bold: set_Bold,
+    text_Is_Italic: set_Italic,
+    text_Is_Underline: set_Underline,
+    text_Is_Antialias: set_Antialias,
+    text_Is_Strikethrough: set_Strikethrough,
+    text_have_background: set_have_Background,
+    ##########
+    #VFLAG
+    ##########
+    bg_widget: fill_bg,
+    border: set_border,
+    corner_radius: set_border,
+    textpack: draw_text,
+    ###########
+    #RFLAG
+    ###########
+    Rbg_widget : Remove_bg,
+    Rborder : Remove_border,
+    Rcorner_radius : corner_radius,
+    Rtext_Is_Bold : Remove_textBold,
+    Rtext_Is_Italic : Remove_textItalic,
+    Rtext_Is_Underline : Remove_textUnderline,
+    Rtext_Is_Strikethrough : Remove_textStrikethrough,
+    Rtext_Is_Antialias : Remove_textAntialias,
+    Rtext_have_background : Remove_textBg,
+    RDownrclick: notingfunc,
+    RDownlclick: notingfunc,
+    RDownscrollmouse: notingfunc,
+    RDownscrollup: notingfunc,
+    RDownscrolldown: notingfunc,
+    RUprclick: notingfunc,
+    RUplclick: notingfunc,
+    RUpscrollmouse: notingfunc,
+    RUpscrollup: notingfunc,
+    RUpscrolldown: notingfunc,
+    RHover_func : notingfunc,
+    Rhover_bg : notingfunc,
+    Rpressed_bg: notingfunc,
+    RRealeasefunc: notingfunc,
+    Rhave_margin: notingfunc,
+    #########
+    #AFLAG
+    #########
+    text_auto_resize: text_resize,
+    have_margin: notingfunc,
+    ########
+    #EFLAG
+    ########
+    Downrclick : notingfunc,
+    Downlclick : notingfunc,
+    Downscrollmouse : notingfunc,
+    Downscrollup : notingfunc,
+    Downscrolldown  :notingfunc,
+    Uprclick :notingfunc ,
+    Uplclick  : notingfunc,
+    Upscrollmouse  :notingfunc,
+    Upscrollup : notingfunc,
+    Upscrolldown: notingfunc,
+    hover_bg: notingfunc,
+    pressed_bg: notingfunc,
+    Hoverfunc: notingfunc,
+    Realeasefunc: notingfunc
+}