PGTKernelBasic 0.22.0__py3-none-any.whl

Kernel/PgRenderCompo/RRender.py

@@ -0,0 +1,84 @@
+from Kernel.PgRenderCompo.Render import *
+from Kernel.RFlags import *
+from Kernel.KernelWidget import Widget
+from Kernel.PgRenderCompo.TextObj import Label
+def Remove_bg(widget: Widget, screen):
+    if border in widget.vflags:
+        set_border(widget, screen)
+    widget.hide_itself()
+def Remove_border(widget: Widget, screen):
+    if bg_widget in widget.vflags:
+        fill_bg(widget, screen)
+    else:
+        widget.hide_itself()
+def Remove_corner_radius(widget: Widget, screen):
+    if border in widget.vflags:
+        valpack = widget.vflags[border]
+        pygame.draw.rect(screen, valpack.border_col, widget.get_rect(), valpack.border_width)
+def Remove_textpack(label: Label, screen):
+    if bg_widget in label.vflags:
+        fill_bg(label, screen)
+    elif border in label.vflags:
+        set_border(label, screen)
+    else:
+        widget.hide_itself()
+def Remove_textBold(label: Label, screen):
+    label.dirty_auto_flag.add(text_auto_resize)
+    if bg_widget in label.vflags:
+        fill_bg(label, screen)
+    else:
+        label.hide_itself()
+    label.font.set_bold(False)
+    text_surface = label.font.render(label.textpack.Text, label.smooth, label.textpack.Color)
+    screen.blit(text_surface, label.get_pos())
+def Remove_textItalic(label: Label, screen):
+    label.dirty_auto_flag.add(text_auto_resize)
+    if bg_widget in label.vflags:
+        fill_bg(label, screen)
+    else:
+        label.hide_itself()
+    label.font.set_italic(False)
+    text_surface = label.font.render(label.textpack.Text, label.smooth, label.textpack.Color)
+    screen.blit(text_surface, label.get_pos())
+def Remove_textUnderline(label:Label, screen):
+    label.dirty_auto_flag.add(text_auto_resize)
+    if bg_widget in label.vflags:
+        fill_bg(label, screen)
+    else:
+        label.hide_itself()
+    label.font.set_underline(False)
+    text_surface = label.font.render(label.textpack.Text, label.smooth, label.textpack.Color)
+    screen.blit(text_surface, label.get_pos())
+def Remove_textStrikethrough(label:Label, screen):
+    label.dirty_auto_flag.add(text_auto_resize)
+    if bg_widget in label.vflags:
+        fill_bg(label, screen)
+    else:
+        label.hide_itself()
+    label.font.set_strikethrough(False)
+    text_surface = label.font.render(label.textpack.Text, label.smooth, label.textpack.Color)
+    screen.blit(text_surface, label.get_pos())
+def Remove_textAntialias(label : Label, screen):
+    if bg_widget in label.vflags:
+        fill_bg(label, screen)
+    else:
+        label.hide_itself()
+    label.smooth = False
+    text_surface = label.font.render(label.textpack.Text, label.smooth, label.textpack.Color)
+    screen.blit(text_surface, label.get_pos())
+def Remove_textBg(label: Label, screen):
+    label.hide_itself()
+    font = label.font if hasattr(label, 'font') else \
+        pygame.font.SysFont(label.textpack.Font, label.textpack.Size)
+
+    font.set_bold(text_Is_Bold in label.uflags)
+    font.set_italic(text_Is_Italic in label.uflags)
+    font.set_underline(text_Is_Underline in label.uflags)
+    font.set_strikethrough(text_Is_Strikethrough in label.uflags)
+
+    text_surface = font.render(
+        label.textpack.Text,
+        text_Is_Antialias in label.uflags,
+        label.textpack.Color
+    )
+    screen.blit(text_surface, label.get_pos())

Kernel/PgRenderCompo/Render.py

@@ -0,0 +1,78 @@
+import pygame
+
+from Kernel.VFlags import *
+from Kernel.UFlags import *
+from Kernel.KernelWidget import Widget
+from Kernel.PgRenderCompo.TextObj import Label
+
+"""
+Surface
+"""
+
+
+def get_rounded_surface(surface, radius):
+    size = surface.get_size()
+    target = pygame.Surface(size, pygame.SRCALPHA)
+    target.fill((0, 0, 0, 0))
+    pygame.draw.rect(target, (255, 255, 255, 255), (0, 0, size[0], size[1]), border_radius=radius)
+    target.blit(surface, (0, 0), special_flags=pygame.BLEND_RGBA_MIN)
+    return target
+def fill_bg(widget: Widget, screen: pygame.Surface):
+    bg = widget.vflags[bg_widget]
+    radius = widget.vflags.get(corner_radius, 0)
+    if isinstance(bg, tuple):
+        pygame.draw.rect(screen, bg, (widget.rect.x, widget.rect.y, widget.rect.w, widget.rect.h), border_radius=radius)
+    elif isinstance(bg, pygame.Surface):
+        cache_key = f"_rounded_bg_cache_{widget.rect.w}_{widget.rect.h}_{radius}"
+        rounded_bg = getattr(widget, cache_key, None)
+        if rounded_bg is None:
+            scaled_bg = pygame.transform.smoothscale(bg, (int(widget.rect.w), int(widget.rect.h)))
+            if radius > 0:
+                rounded_bg = get_rounded_surface(scaled_bg, radius)
+            else:
+                rounded_bg = scaled_bg
+            setattr(widget, cache_key, rounded_bg)
+        screen.blit(rounded_bg, (widget.rect.x, widget.rect.y))
+def set_border(widget: Widget, screen):
+    valpack = widget.vflags[border]
+    if corner_radius in widget.vflags:
+        pygame.draw.rect(screen, valpack.border_col, widget.get_rect(), valpack.border_width, widget.vflags[corner_radius])
+    else:
+        pygame.draw.rect(screen, valpack.border_col, widget.get_rect(), valpack.border_width)
+"""
+Text
+"""
+def draw_text(label: Label, screen):
+    text_surface = label.font.render(label.textpack.Text, label.smooth, label.textpack.Color, label.bg)
+    screen.blit(text_surface, label.get_pos())
+def set_Bold(label: Label):
+    label.font.set_bold(True)
+    label.dirty_vflags.add(textpack)
+    label.dirty_auto_flag.add(text_auto_resize)
+def set_Italic(label: Label):
+    label.font.set_italic(True)
+    label.dirty_vflags.add(textpack)
+    label.hide_itself()
+    label.dirty_auto_flag.add(text_auto_resize)
+def set_Underline(label: Label):
+    label.font.set_underline(True)
+    label.dirty_vflags.add(textpack)
+    label.hide_itself()
+    label.dirty_auto_flag.add(text_auto_resize)
+def set_Strikethrough(label: Label):
+    label.font.set_strikethrough(True)
+    label.dirty_vflags.add(textpack)
+    label.dirty_auto_flag.add(text_auto_resize)
+def set_Antialias(label: Label):
+    label.smooth = True
+    label.dirty_vflags.add(textpack)
+def set_have_Background(label: Label):
+    if bg_widget in label.vflags:
+        label.bg = label.vflags[bg_widget]
+        label.dirty_vflags.add(textpack)
+    else:
+        raise ValueError('Background color is not found')
+def text_resize(label: Label):
+    text_surface = label.font.render(label.textpack.Text, label.smooth, label.textpack.Color)
+    new_size = text_surface.get_size()
+    label.Size_update(new_size)

Kernel/PgRenderCompo/TextObj.py

@@ -0,0 +1,127 @@
+import pygame
+
+from Kernel.PgRenderCompo.ButtonObj import FixedButton
+from Kernel.UFlags import *
+from Kernel.KernelWidget import Widget, MainScreen
+from Kernel.ObjType import RectTuple, PosTuple, TextPack, Border
+from Kernel.VFlags import *
+import re
+def trashfunc(*args, **kwargs):
+    pass
+re_search = re.search
+re_findall = re.findall
+re_sub = re.sub
+re_split = re.split
+re_match = re.match
+re_compile = re.compile
+re_escape = re.escape
+EMAIL_PATTERN = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
+URL_PATTERN = re.compile(r'https?://\S+')
+HASHTAG_PATTERN = re.compile(r'#\w+')
+MENTION_PATTERN = re.compile(r'@\w+')
+def extract_emails(text):
+    return EMAIL_PATTERN.findall(text)
+def extract_urls(text):
+    return URL_PATTERN.findall(text)
+def extract_hashtags(text):
+    return HASHTAG_PATTERN.findall(text)
+def safe_substitute(text, pattern, replacement):
+    """Safe regex substitution với escape"""
+    return re_sub(re_escape(pattern), replacement, text)
+#wrap
+SysFont = pygame.font.SysFont
+Font = pygame.font.Font
+class Label(Widget):
+    __slots__ = ('font', 'textpack', 'smooth', 'bg')
+    def __init__(self, parent: Widget  | MainScreen, color,
+                 size, text,
+                  Uflags: set | tuple = (), pos : PosTuple=(0, 0), font ="timesnewroman", name: None | str = None):
+        self.textpack = TextPack(color, font, size, text)
+        self.font = pygame.font.SysFont(self.textpack.Font, self.textpack.Size)
+        text_surface = self.font.render(self.textpack.Text, False, self.textpack.Color)
+        pygameRect = text_surface.get_rect()
+        x,y = pos
+        tuple_rect = (x,y,pygameRect.w, pygameRect.h)
+        super().__init__(parent, rect=tuple_rect,name=name, can_change=True)
+        self.add_vflag((textpack, TextPack(color, font, size, text)))
+        if isinstance(Uflags, set):
+            self.uflags = Uflags
+            self.dirty_uflags = Uflags
+        else:
+            for flag in Uflags:
+                self.add_uflag(flag)
+        self.smooth = text_Is_Antialias in self.uflags
+        self.bg = None
+    def smooth_update(self):
+        self.smooth = text_Is_Antialias in self.uflags
+    def Rect_update(self, rect: RectTuple):
+        self.rect.x = rect[0]
+        self.rect.y = rect[1]
+        self.rect.w = rect[2]
+        self.rect.h = rect[3]
+    def Size_update(self, size: PosTuple):
+        self.rect.w = size[0]
+        self.rect.h = size[1]
+    def change_text(self, new_text: str):
+        self.hide_itself()
+        self.textpack.Text = new_text
+        new_w, new_h = self.font.size(self.textpack.Text)
+        self.Size_update((new_w, new_h))
+        self.dirty_vflags.add(textpack)
+class LineEdit(FixedButton):
+    def __init__(self, parent,  text_size, width_line_edit ,pos: PosTuple=(0,0), bg=(255,255,255),
+                 text_color=(0,0,0), border_radius=4, border_width=1, border_color = (0,0,0),
+                 text_font="timesnewroman", text_uflags=None, pad_x=8, pad_y=4, name: str | None = None):
+        text_uflags = {text_Is_Antialias} if not text_uflags else text_uflags
+        text_pos = (pad_x + border_width, pad_y + border_width)
+        temp_font = pygame.font.SysFont(text_font, text_size)
+        height_line_edit = temp_font.get_height() + pad_y * 2 + border_width * 2
+        rect = (pos[0], pos[1], width_line_edit, height_line_edit)
+        super().__init__(parent, rect, bg, name=name)
+        self.label = Label(self, text_color, text_size, "", text_uflags, text_pos, font=text_font)
+        self.add_vflag((border, Border(border_width, border_color)))
+        self.add_vflag((corner_radius, border_radius))
+        self.text = self.label.textpack.Text
+        self.display_text = self.text
+        self.fully = False
+        self.display_start = 0
+        self.pad_x = pad_x
+        self.pad_y = pad_y
+
+    def _update_display_offset(self):
+        b_width = self.vflags[border].border_width
+        max_width = self.rect.w - self.pad_x * 2 - b_width * 2
+        while True:
+            current_w = self.label.font.size(self.text[self.display_start:])[0]
+            if current_w <= max_width or self.display_start >= len(self.text):
+                break
+            self.display_start += 1
+            self.fully = True
+        while self.display_start > 0:
+            test_start = self.display_start - 1
+            test_w = self.label.font.size(self.text[test_start:])[0]
+            if test_w <= max_width:
+                self.display_start = test_start
+            else:
+                break
+        if self.display_start == 0:
+            self.fully = False
+        self.label.change_text(self.text[self.display_start:])
+    def process_addchar(self, char: str):
+        self.text += char
+        self._update_display_offset()
+    def process_backspace(self):
+        if len(self.text) > 0:
+            self.text = self.text[:-1]
+            self._update_display_offset()
+
+    def dispatch_hover(self, mouse_pos):
+        pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_IBEAM)
+        return super().dispatch_hover(mouse_pos)
+
+    def dispatch_release(self, mouse_pos):
+        pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_ARROW)
+        return super().dispatch_release(mouse_pos)
+    def clear_text(self):
+        self.text = ""
+        self._update_display_offset()

Kernel/PgRenderCompo/__init__.py

@@ -0,0 +1,5 @@
+from Kernel.PgRenderCompo.LinkRenderfunc import *
+from Kernel.PgRenderCompo.RRender import *
+from Kernel.PgRenderCompo.Render import *
+from Kernel.PgRenderCompo.TextObj import *
+from Kernel.PgRenderCompo.ButtonObj import *

Kernel/RFlags.py

@@ -0,0 +1,63 @@
+from Kernel.UFlags import *
+from Kernel.VFlags import *
+"""
+RUFLAGS
+"""
+Rtext_Is_Bold = text_Is_Bold + 2000
+Rtext_Is_Italic = text_Is_Italic + 2000
+Rtext_Is_Underline = text_Is_Underline + 2000
+Rtext_Is_Strikethrough = text_Is_Strikethrough + 2000
+Rtext_Is_Antialias = text_Is_Antialias + 2000
+Rtext_have_background = text_have_background + 2000
+Rhave_margin = have_margin + 2000
+"""
+RVflags
+"""
+Rbg_widget = bg_widget + 2000
+Rborder = border + 2000
+Rcorner_radius = corner_radius + 2000
+Rtextpack = textpack + 2000
+RDownrclick = Downrclick + 2000
+RDownlclick = Downlclick + 2000
+RDownscrollmouse = Downscrollmouse + 2000
+RDownscrollup = Downscrollup + 2000
+RDownscrolldown = Downscrolldown + 2000
+RUprclick = Uprclick + 2000
+RUplclick =  Uplclick + 2000
+RUpscrollmouse = Upscrollmouse + 2000
+RUpscrollup = Upscrollup + 2000
+RUpscrolldown = Upscrolldown + 2000
+Rhover_bg = hover_bg + 2000
+Rpressed_bg = pressed_bg + 2000
+RHover_func = Hoverfunc + 2000
+RRealeasefunc = Realeasefunc + 2000
+"""
+Link Rflag to Uflag, Vflag
+"""
+rflags_to_uflags = {
+    text_Is_Bold: Rtext_Is_Bold,
+    text_Is_Italic: Rtext_Is_Italic,
+    text_Is_Underline: Rtext_Is_Underline,
+    text_Is_Strikethrough: Rtext_Is_Strikethrough,
+    text_Is_Antialias: Rtext_Is_Antialias,
+    text_have_background: Rtext_have_background,
+    have_margin: Rhave_margin
+}
+rflags_to_vflags = {
+    bg_widget: Rbg_widget,
+    border: Rborder,
+    corner_radius: Rcorner_radius,
+    textpack: Rtextpack,
+    Downrclick: RDownrclick,
+    Downlclick: RDownlclick,
+    Downscrollmouse: RDownscrollmouse,
+    Downscrolldown: RDownscrolldown,
+    Downscrollup: RDownscrollup,
+    Uprclick: RUprclick,
+    Uplclick: RUplclick,
+    Upscrollmouse: RUpscrollmouse,
+    Upscrollup: RUpscrollup,
+    Upscrolldown: RUpscrolldown,
+    Hoverfunc: RHover_func,
+    Realeasefunc: RRealeasefunc
+}

Kernel/UFlags.py

@@ -0,0 +1,18 @@
+##########
+#COMMON
+##########
+have_margin = 1
+############
+#LABEL
+############
+text_Is_Bold = have_margin + 1
+text_Is_Italic = text_Is_Bold + 1
+text_Is_Underline = text_Is_Italic + 1
+text_Is_Strikethrough = text_Is_Underline + 1
+text_Is_Antialias = text_Is_Strikethrough + 1
+text_have_background = text_Is_Antialias + 1
+
+###########
+#Aflags
+###########
+text_auto_resize = 4001

Kernel/VFlags.py

@@ -0,0 +1,29 @@
+##########
+#COMMON
+##########
+
+bg_widget = 1001 # Not for Label
+border = bg_widget + 1 # Not for Label
+corner_radius = border + 1 # Not for Label
+#########
+#LABEL
+########
+textpack = corner_radius + 1
+##########
+#BUTTON
+##########
+Downrclick = textpack + 1
+Downlclick = Downrclick + 1
+Downscrollmouse = Downlclick + 1
+Downscrollup = Downscrollmouse + 1
+Downscrolldown = Downscrollup + 1
+Uprclick = Downscrolldown + 1
+Uplclick =  Uprclick + 1
+Upscrollmouse = Uplclick + 1
+Upscrollup = Upscrollmouse + 1
+Upscrolldown = Upscrollup + 1
+hover_bg = Upscrolldown + 1
+pressed_bg = hover_bg + 1
+Hoverfunc = pressed_bg + 1
+Realeasefunc = Hoverfunc + 1
+print(Downlclick)

Kernel/__init__.py

@@ -0,0 +1,15 @@
+from .KernelColor import *
+from .KernelPosition import *
+from .geometry import *
+from .KernelWidget import *
+from .ObjType import *
+from .KernalInit import *
+from .PgRenderCompo import *
+from .ImageObj import *
+from .KernelAudio import *
+from .KernelLayout import *
+from .KernelEvent import *
+from .KernelRun import *
+from .VFlags import *
+from .UFlags import *
+from .RFlags import *

Kernel/geometry.py

@@ -0,0 +1,117 @@
+#v0.09
+from Kernel import KernalInit
+import math
+KernalInit.init()
+#wrap some useful function from a math lib
+sqrt = math.sqrt
+atan2 = math.atan2
+degrees = math.degrees
+radians = math.radians
+cos = math.cos
+sin = math.sin
+pi = math.pi
+def to_vector(pos_x:float, pos_y:float):
+    """change 2 pos to a vector"""
+    return pos_y - pos_x
+def magnitude(vec):
+    """return the distance of two pos"""
+    return math.sqrt(vec[0]*vec[0] + vec[1]*vec[1])
+def vector_between(p1, p2):
+    """return the vector between two pos"""
+    return p2[0] - p1[0], p2[1] - p1[1]
+def normalize(vec):
+    """Return unit vector."""
+    mag = magnitude(vec)
+    if mag == 0:
+        return 0.0, 0.0
+    return vec[0] / mag, vec[1] / mag
+def midpoint(p1, p2):
+    """
+    return the pos of the midpoint in the line
+    """
+    return (p1[0] + p2[0]) * 0.5, (p1[1] + p2[1]) * 0.5
+def point_on_circle(center, radius, angle_deg):
+    """
+    return position of the point in the circle
+    """
+    rad = math.radians(angle_deg)
+    return (center[0] + radius * math.cos(rad),
+            center[1] + radius * math.sin(rad))
+def clamp_point(point, rect):
+    """Clamp point to be inside rect (pygame.Rect or (x,y,w,h))."""
+    x, y = point
+    rx, ry, rw, rh = rect
+    return (max(rx, min(x, rx + rw)),
+            max(ry, min(y, ry + rh)))
+def vector_to_angle(dx, dy):
+    """
+    Return angle in degrees (0° to 360°) of vector (dx, dy).
+    0° points to the right (positive X), 90° points down (positive Y in pygame).
+    """
+    # math.atan2(dy, dx) returns radians, convert to degrees
+    angle_rad = math.atan2(dy, dx)
+    angle_deg = math.degrees(angle_rad)
+    # Normalize to 0–360
+    return angle_deg % 360.0
+# Rect utilities
+def rect_intersection(rect1, rect2):
+    """Return overlapping rect as pygame.Rect, or None if no intersection."""
+    x1 = max(rect1[0], rect2[0])
+    y1 = max(rect1[1], rect2[1])
+    x2 = min(rect1[0] + rect1[2], rect2[0] + rect2[2])
+    y2 = min(rect1[1] + rect1[3], rect2[1] + rect2[3])
+    if x2 > x1 and y2 > y1:
+        return x1, y1, x2 - x1, y2 - y1
+    return None
+def rect_union(rect1, rect2):
+    """Return the smallest rect containing both rects."""
+    x1 = min(rect1[0], rect2[0])
+    y1 = min(rect1[1], rect2[1])
+    x2 = max(rect1[0] + rect1[2], rect2[0] + rect2[2])
+    y2 = max(rect1[1] + rect1[3], rect2[1] + rect2[3])
+    return x1, y1, x2 - x1, y2 - y1
+
+def rotate_point(point, center, angle_deg):
+    """
+    Rotate a point around a center by a given angle (degrees).
+    Positive angle = counter‑clockwise (mathematical convention).
+    """
+    px, py = point
+    cx, cy = center
+    rad = radians(angle_deg)
+    cos_a = cos(rad)
+    sin_a = sin(rad)
+
+    # Translate to origin
+    dx = px - cx
+    dy = py - cy
+
+    # Rotate
+    rx = dx * cos_a - dy * sin_a
+    ry = dx * sin_a + dy * cos_a
+
+    # Translate back
+    return rx + cx, ry + cy
+def pytagore(a, b):
+    """Return sqrt(a² + b²) – Pythagorean distance for a right triangle."""
+    return sqrt(a*a + b*b)
+def law_of_cosines(a, b, angle_deg):
+    """Return length of side c given sides a, b and included angle C in degrees."""
+    rad = radians(angle_deg)
+    return sqrt(a*a + b*b - 2*a*b*cos(rad))
+def triangle_area(p1, p2, p3):
+    """Area of triangle given three points (x, y)."""
+    x1, y1 = p1
+    x2, y2 = p2
+    x3, y3 = p3
+    return abs((x1*(y2 - y3) + x2*(y3 - y1) + x3*(y1 - y2)) / 2.0)
+def point_line_distance(point, line_p1, line_p2):
+    """Distance from point to line defined by two points."""
+    x0, y0 = point
+    x1, y1 = line_p1
+    x2, y2 = line_p2
+    numerator = abs((x2-x1)*(y1-y0) - (x1-x0)*(y2-y1))
+    denominator = sqrt((x2-x1)**2 + (y2-y1)**2)
+    if denominator == 0:
+        return distance(point, line_p1)  # a line is a point
+    return numerator / denominator

pgtkernelbasic-0.22.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: PGTKernelBasic
+Version: 0.22.0
+Summary: Lightweight UI framework for Pygame
+Author: Your Name
+Requires-Python: >=3.8
+Requires-Dist: pygame>=2.5.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

pgtkernelbasic-0.22.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+Kernel/ImageObj.py,sha256=l5YqW-Ec8-y__FeDstFZMHjiFZM8oEvLpbu16eaZbbI,2123
+Kernel/KernalInit.py,sha256=vSOKLSx3-mq9wrq0qvgoffpC0bOCtDa55gJW2yvIjSg,428
+Kernel/KernelAudio.py,sha256=Ok3fItLbBS6soVL6RafOjk6kF6SKdnUt4OBXt9s95ok,3328
+Kernel/KernelColor.py,sha256=VAuCAJYxbTT7q_5q8AXvNBI6hm2me7wyES0fgNQo56A,11688
+Kernel/KernelEvent.py,sha256=uSG7WiAMYYxYcS2vnhYSAFRJp0mdJrQyy31gO5DOrzE,4962
+Kernel/KernelLayout.py,sha256=qmT51niftTM3BXLsIvQZ_FnpBbEYN6O897HtffndrfY,2181
+Kernel/KernelPosition.py,sha256=MiBa9e3Y8Bwn7ZAzPg6Rpjlk5A5_m3rf12qDW1U-kko,8837
+Kernel/KernelRun.py,sha256=sTJjybXbztF-Toa8saCh6bei-uAPmkCEBO1SCK7sTlY,3269
+Kernel/KernelWidget.py,sha256=jnixXqRTmXsMzFplEyvv0GDhG6cKv_ZBbmfX3dZfaKc,14153
+Kernel/ObjType.py,sha256=nMDAW4X9sQXJVHp_GZ9VWGwpbiYvACa4CAulWQHhIEE,519
+Kernel/RFlags.py,sha256=5a1_spKQTs5_jKWPb3oCdIb982difdg7eajAIYxpHFc,1900
+Kernel/UFlags.py,sha256=sUYj_ZJVNvJc6FoEz3Cx0po5RRDmm523eC2j8l2XkUY,393
+Kernel/VFlags.py,sha256=vC5NmxwffemPbDr4v33nKjwmE_w4hzTvIXfzKnVoQT4,687
+Kernel/__init__.py,sha256=mMRCcLAqvAIgSKx-ua5RLHUvndSp8Xrf9NLCdMerVL0,397
+Kernel/geometry.py,sha256=NVS79eW6f5qjM-yDgOwVR7658IVbBR1DwCjA0s2Iys8,3916
+Kernel/PgRenderCompo/ButtonObj.py,sha256=9GIyI5ALCLivVTK0tM6d1ulIB2YLR_0DEYjlIWEii_4,7182
+Kernel/PgRenderCompo/LinkRenderfunc.py,sha256=FU1QBj8d8IZl7AQJ6604O72fwk-e95p0IbfeDFCD4XM,2024
+Kernel/PgRenderCompo/RRender.py,sha256=chAI4igqbJpY8s79-UCpT9jijHoHmpXwIeqe32fUjeo,3362
+Kernel/PgRenderCompo/Render.py,sha256=TaG5gMO5Hp50h2EQLFi4n5ilKlVoLzQXzGRJsGSpwTU,3164
+Kernel/PgRenderCompo/TextObj.py,sha256=9g_U35WEaYO3gvSH-Ooj-6nf7M9p7uBygxj4tyaToyg,5430
+Kernel/PgRenderCompo/__init__.py,sha256=zr0m8zWkT6lXVSy5v4ls8TaQKqhU6eUc53QQCye2jOM,226
+pgtkernelbasic-0.22.0.dist-info/METADATA,sha256=I8pwS98eHWe2ZDnzjdvSLPPuIBbbgmv659YJct2jXPQ,266
+pgtkernelbasic-0.22.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pgtkernelbasic-0.22.0.dist-info/top_level.txt,sha256=3u1ALZzWhzGJKcnPs01FzOXDJ0qJMXClfgsjPEsOtPE,7
+pgtkernelbasic-0.22.0.dist-info/RECORD,,

pgtkernelbasic-0.22.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pgtkernelbasic-0.22.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+Kernel