cuifw 1.0.0__py3-none-any.whl

cuifw/__init__.py

@@ -0,0 +1,2012 @@
+"""
+cuifw - The best Console Library of the Python
+
+A lightweight library for terminal-based applications with support for:
+- ANSI colors and styling
+- 2D/3D rendering in terminal
+- Keyboard input handling
+- Process management
+- Simple networking (sockets)
+- Built-in web server
+- Console animations
+
+Author: Suleiman
+License: MIT
+Copyright © Suleiman 2026
+"""
+import os
+import sys
+import time
+import math
+import random
+import socket
+import subprocess as CMD
+import threading
+import webbrowser
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import urllib.request
+import urllib.parse
+
+class Colors:
+    RESET = "\033[0m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    BLUE = "\033[34m"
+    CYAN = "\033[36m"
+    MAGENTA = "\033[35m"
+    YELLOW = "\033[33m"
+    WHITE = "\033[37m"
+    BLACK = "\033[30m"
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_BLUE = "\033[44m"
+    BG_CYAN = "\033[46m"
+    BG_MAGENTA = "\033[45m"
+    BG_YELLOW = "\033[43m"
+    BG_WHITE = "\033[47m"
+    BG_BLACK = "\033[40m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    ITALIC = "\033[3m"
+    UNDERLINE = "\033[4m"
+    BLINK = "\033[5m"
+    REVERSE = "\033[7m"
+    HIDDEN = "\033[8m"
+    STRIKE = "\033[9m"
+    
+    @staticmethod
+    def rgb(r, g, b):
+        return f"\033[38;2;{r};{g};{b}m"
+    
+    @staticmethod
+    def bg_rgb(r, g, b):
+        return f"\033[48;2;{r};{g};{b}m"
+    
+    @staticmethod
+    def colorize(text, color, reset=True):
+        reset_code = Colors.RESET if reset else ""
+        return f"{color}{text}{reset_code}"
+
+class Render:
+    @staticmethod
+    def DrawPic(points=None, width=80, height=25, clear_before_draw=False, default_char=' '):
+        if clear_before_draw:
+            os.system("cls" if os.name == "nt" else "clear")
+        field = [[default_char for _ in range(width)] for _ in range(height)]
+        if points:
+            for item in points:
+                if len(item) >= 3:
+                    x, y, char = item[0], item[1], item[2]
+                    if 0 <= x < width and 0 <= y < height:
+                        if len(item) == 4:
+                            color = item[3]
+                            field[y][x] = f"{color}{char}{Colors.RESET}"
+                        elif len(item) == 5:
+                            color, bg = item[3], item[4]
+                            field[y][x] = f"{color}{bg}{char}{Colors.RESET}"
+                        else:
+                            field[y][x] = char
+        for row in field:
+            print(''.join(row))
+    @staticmethod
+    def _apply_color(points, color=None, bg=None):
+        if color is None and bg is None:
+            return points
+        result = []
+        for p in points:
+            if len(p) == 3:
+                x, y, char = p
+                if color and bg:
+                    result.append((x, y, char, color, bg))
+                elif color:
+                    result.append((x, y, char, color))
+                else:
+                    result.append((x, y, char, Colors.BG_BLACK + bg))
+            else:
+                result.append(p)
+        return result
+
+    @staticmethod
+    def get_line_points(x1, y1, x2, y2, char='#', color=None, bg=None):
+        points = []
+        dx = abs(x2 - x1)
+        dy = abs(y2 - y1)
+        sx = 1 if x1 < x2 else -1
+        sy = 1 if y1 < y2 else -1
+        err = dx - dy
+        while True:
+            points.append((x1, y1, char))
+            if x1 == x2 and y1 == y2:
+                break
+            e2 = err * 2
+            if e2 > -dy:
+                err -= dy
+                x1 += sx
+            if e2 < dx:
+                err += dx
+                y1 += sy
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_circle_points(cx, cy, r, char='#', color=None, bg=None):
+        points = []
+        for angle in range(0, 360, 5):
+            rad = angle * math.pi / 180
+            x = int(cx + r * math.cos(rad))
+            y = int(cy + r * math.sin(rad))
+            points.append((x, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_filled_circle_points(cx, cy, r, char='#', color=None, bg=None):
+        points = []
+        for y in range(cy - r, cy + r + 1):
+            for x in range(cx - r, cx + r + 1):
+                if (x - cx) ** 2 + (y - cy) ** 2 <= r ** 2:
+                    points.append((x, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_rect_points(x1, y1, x2, y2, char='#', color=None, bg=None):
+        points = []
+        for x in range(x1, x2 + 1):
+            points.append((x, y1, char))
+            points.append((x, y2, char))
+        for y in range(y1, y2 + 1):
+            points.append((x1, y, char))
+            points.append((x2, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_fill_rect_points(x1, y1, x2, y2, char='#', color=None, bg=None):
+        points = []
+        for y in range(y1, y2 + 1):
+            for x in range(x1, x2 + 1):
+                points.append((x, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_text_points(x, y, text, char=None, color=None, bg=None):
+        points = []
+        if char is None:
+            for i, ch in enumerate(text):
+                points.append((x + i, y, ch))
+        else:
+            for i in range(len(text)):
+                points.append((x + i, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_triangle_points(x1, y1, x2, y2, x3, y3, char='#', color=None, bg=None):
+        points = []
+        points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        points.extend(Render.get_line_points(x2, y2, x3, y3, char))
+        points.extend(Render.get_line_points(x3, y3, x1, y1, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_filled_triangle_points(x1, y1, x2, y2, x3, y3, char='#', color=None, bg=None):
+        points = []
+        min_x = min(x1, x2, x3)
+        max_x = max(x1, x2, x3)
+        min_y = min(y1, y2, y3)
+        max_y = max(y1, y2, y3)
+        for y in range(min_y, max_y + 1):
+            for x in range(min_x, max_x + 1):
+                if Render._point_in_triangle(x, y, x1, y1, x2, y2, x3, y3):
+                    points.append((x, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_heart_points(cx, cy, size=5, char='#', color=None, bg=None):
+        points = []
+        for y in range(-size, size + 1):
+            for x in range(-size, size + 1):
+                if ((x * x + y * y - size * size) ** 3 <= size * size * x * x * y * y * 0.5):
+                    points.append((cx + x, cy - y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_star_points(cx, cy, radius=5, points_count=5, char='*', color=None, bg=None):
+        points = []
+        angle = -math.pi / 2
+        step = math.pi / points_count
+        outer_points = []
+        inner_points = []
+        for i in range(points_count * 2):
+            r = radius if i % 2 == 0 else radius * 0.4
+            x = cx + r * math.cos(angle + i * step)
+            y = cy + r * math.sin(angle + i * step)
+            if i % 2 == 0:
+                outer_points.append((x, y))
+            else:
+                inner_points.append((x, y))
+        for i in range(points_count):
+            p1 = outer_points[i]
+            p2 = inner_points[i]
+            p3 = outer_points[(i + 1) % points_count]
+            points.extend(Render.get_line_points(int(p1[0]), int(p1[1]), int(p2[0]), int(p2[1]), char))
+            points.extend(Render.get_line_points(int(p2[0]), int(p2[1]), int(p3[0]), int(p3[1]), char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_bezier_points(x1, y1, x2, y2, x3, y3, steps=20, char='#', color=None, bg=None):
+        points = []
+        for t in range(steps + 1):
+            t = t / steps
+            x = (1 - t) ** 2 * x1 + 2 * (1 - t) * t * x2 + t ** 2 * x3
+            y = (1 - t) ** 2 * y1 + 2 * (1 - t) * t * y2 + t ** 2 * y3
+            points.append((int(x), int(y), char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_wave_points(cx, cy, amplitude=5, length=20, char='~', color=None, bg=None):
+        points = []
+        for x in range(length):
+            y = cy + int(amplitude * math.sin(x * 0.5))
+            points.append((cx + x, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_spiral_points(cx, cy, turns=3, radius=10, step=0.1, char='*', color=None, bg=None):
+        points = []
+        angle = 0
+        r = 0
+        while r < radius:
+            x = int(cx + r * math.cos(angle))
+            y = int(cy + r * math.sin(angle))
+            points.append((x, y, char))
+            angle += step
+            r += step * 2
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_grid_points(x1, y1, x2, y2, step=2, char='+', color=None, bg=None):
+        points = []
+        for x in range(x1, x2 + 1, step):
+            for y in range(y1, y2 + 1, step):
+                points.append((x, y, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_noise_points(cx, cy, radius, count=50, char='.', color=None, bg=None):
+        points = []
+        for _ in range(count):
+            angle = random.uniform(0, 2 * math.pi)
+            r = random.uniform(0, radius)
+            x = int(cx + r * math.cos(angle))
+            y = int(cy + r * math.sin(angle))
+            points.append((x, y, char))
+        return Render._apply_color(points, color, bg)
+
+    # ---- 3D ----
+    @staticmethod
+    def _point_in_triangle(px, py, x1, y1, x2, y2, x3, y3):
+        def sign(a, b, c):
+            return (a[0] - c[0]) * (b[1] - c[1]) - (b[0] - c[0]) * (a[1] - c[1])
+        p = (px, py)
+        d1 = sign(p, (x2, y2), (x1, y1))
+        d2 = sign(p, (x3, y3), (x2, y2))
+        d3 = sign(p, (x1, y1), (x3, y3))
+        has_neg = (d1 < 0) or (d2 < 0) or (d3 < 0)
+        has_pos = (d1 > 0) or (d2 > 0) or (d3 > 0)
+        return not (has_neg and has_pos)
+
+    @staticmethod
+    def _rotx(x, y, z, angle):
+        rad = math.radians(angle)
+        cos_a = math.cos(rad)
+        sin_a = math.sin(rad)
+        y_new = y * cos_a - z * sin_a
+        z_new = y * sin_a + z * cos_a
+        return x, y_new, z_new
+
+    @staticmethod
+    def _roty(x, y, z, angle):
+        rad = math.radians(angle)
+        cos_a = math.cos(rad)
+        sin_a = math.sin(rad)
+        x_new = x * cos_a + z * sin_a
+        z_new = -x * sin_a + z * cos_a
+        return x_new, y, z_new
+
+    @staticmethod
+    def _rotz(x, y, z, angle):
+        rad = math.radians(angle)
+        cos_a = math.cos(rad)
+        sin_a = math.sin(rad)
+        x_new = x * cos_a - y * sin_a
+        y_new = x * sin_a + y * cos_a
+        return x_new, y_new, z
+
+    @staticmethod
+    def _project_3d(x, y, z, rotx, roty, rotz, scale, cx, cy):
+        x, y, z = Render._rotx(x, y, z, rotx)
+        x, y, z = Render._roty(x, y, z, roty)
+        x, y, z = Render._rotz(x, y, z, rotz)
+        x2d = int(x * scale + cx)
+        y2d = int(-y * scale + cy)
+        return x2d, y2d
+
+    @staticmethod
+    def get_cube_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
+        s = size / 2
+        vertices = [
+            (-s, -s, -s), (s, -s, -s), (s, s, -s), (-s, s, -s),
+            (-s, -s, s), (s, -s, s), (s, s, s), (-s, s, s)
+        ]
+        edges = [
+            (0,1), (1,2), (2,3), (3,0),
+            (4,5), (5,6), (6,7), (7,4),
+            (0,4), (1,5), (2,6), (3,7)
+        ]
+        points = []
+        projected = []
+        for v in vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for edge in edges:
+            x1, y1 = projected[edge[0]]
+            x2, y2 = projected[edge[1]]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_pyramid_3d_points(size=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
+        s = size / 2
+        vertices = [
+            (-s, -s, -s), (s, -s, -s), (s, -s, s), (-s, -s, s),
+            (0, s, 0)
+        ]
+        edges = [
+            (0,1), (1,2), (2,3), (3,0),
+            (0,4), (1,4), (2,4), (3,4)
+        ]
+        points = []
+        projected = []
+        for v in vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for edge in edges:
+            x1, y1 = projected[edge[0]]
+            x2, y2 = projected[edge[1]]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_cylinder_3d_points(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
+        points = []
+        top_points = []
+        bottom_points = []
+        for i in range(segments):
+            rad = i / segments * 2 * math.pi
+            x = radius * math.cos(rad)
+            z = radius * math.sin(rad)
+            top_points.append((x, height/2, z))
+            bottom_points.append((x, -height/2, z))
+        all_vertices = top_points + bottom_points
+        projected = []
+        for v in all_vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for i in range(segments):
+            j = (i + 1) % segments
+            x1, y1 = projected[i]
+            x2, y2 = projected[j]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+            x1, y1 = projected[i + segments]
+            x2, y2 = projected[j + segments]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+            x1, y1 = projected[i]
+            x2, y2 = projected[i + segments]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_sphere_3d_points(radius=5, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
+        points = []
+        for i in range(segments):
+            theta = i / segments * math.pi
+            for j in range(segments):
+                phi = j / segments * 2 * math.pi
+                x = radius * math.sin(theta) * math.cos(phi)
+                y = radius * math.cos(theta)
+                z = radius * math.sin(theta) * math.sin(phi)
+                x2d, y2d = Render._project_3d(x, y, z, rotx, roty, rotz, scale, cx, cy)
+                points.append((x2d, y2d, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_cone_3d_points(radius=5, height=10, segments=12, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
+        points = []
+        base_points = []
+        for i in range(segments):
+            rad = i / segments * 2 * math.pi
+            x = radius * math.cos(rad)
+            z = radius * math.sin(rad)
+            base_points.append((x, -height/2, z))
+        apex = (0, height/2, 0)
+        all_vertices = base_points + [apex]
+        projected = []
+        for v in all_vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for i in range(segments):
+            j = (i + 1) % segments
+            x1, y1 = projected[i]
+            x2, y2 = projected[j]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+            x1, y1 = projected[i]
+            x2, y2 = projected[-1]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_torus_3d_points(radius=8, tube=3, segments=16, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
+        points = []
+        for i in range(segments):
+            theta = i / segments * 2 * math.pi
+            for j in range(segments):
+                phi = j / segments * 2 * math.pi
+                x = (radius + tube * math.cos(phi)) * math.cos(theta)
+                y = tube * math.sin(phi)
+                z = (radius + tube * math.cos(phi)) * math.sin(theta)
+                x2d, y2d = Render._project_3d(x, y, z, rotx, roty, rotz, scale, cx, cy)
+                points.append((x2d, y2d, char))
+        return Render._apply_color(points, color, bg)
+
+    @staticmethod
+    def get_ico_sphere_3d_points(radius=5, rotx=0, roty=0, rotz=0, scale=10, cx=40, cy=12, char='#', color=None, bg=None):
+        points = []
+        phi = (1 + math.sqrt(5)) / 2
+        vertices = [
+            (-1,  phi, 0), ( 1,  phi, 0), (-1, -phi, 0), ( 1, -phi, 0),
+            ( 0, -1,  phi), ( 0,  1,  phi), ( 0, -1, -phi), ( 0,  1, -phi),
+            ( phi, 0, -1), ( phi, 0,  1), (-phi, 0, -1), (-phi, 0,  1)
+        ]
+        vertices = [(x * radius / 1.618, y * radius / 1.618, z * radius / 1.618) for x, y, z in vertices]
+        edges = [
+            (0,1), (0,4), (0,5), (0,10), (0,11),
+            (1,2), (1,5), (1,7), (1,8), (1,9),
+            (2,3), (2,6), (2,7), (2,10), (2,11),
+            (3,4), (3,6), (3,8), (3,9), (3,11),
+            (4,5), (4,9), (4,11),
+            (5,7), (5,9),
+            (6,7), (6,10),
+            (7,8),
+            (8,9), (8,10),
+            (10,11)
+        ]
+        projected = []
+        for v in vertices:
+            x2d, y2d = Render._project_3d(v[0], v[1], v[2], rotx, roty, rotz, scale, cx, cy)
+            projected.append((x2d, y2d))
+        for edge in edges:
+            x1, y1 = projected[edge[0]]
+            x2, y2 = projected[edge[1]]
+            points.extend(Render.get_line_points(x1, y1, x2, y2, char))
+        return Render._apply_color(points, color, bg)
+
+class Animate:
+    @staticmethod
+    def clear_screen():
+        os.system("cls" if os.name == "nt" else "clear")
+    
+    @staticmethod
+    def animate_print(text, delay=0.05, end="\n", flush=True, backspace_effect=False):
+        if backspace_effect:
+            for ch in text:
+                sys.stdout.write(ch)
+                sys.stdout.flush()
+                time.sleep(delay)
+            time.sleep(0.2)
+            for _ in text:
+                sys.stdout.write("\b \b")
+                sys.stdout.flush()
+                time.sleep(delay / 2)
+            for ch in text:
+                sys.stdout.write(ch)
+                sys.stdout.flush()
+                time.sleep(delay)
+        else:
+            for ch in text:
+                sys.stdout.write(ch)
+                if flush:
+                    sys.stdout.flush()
+                time.sleep(delay)
+        sys.stdout.write(end)
+        if flush:
+            sys.stdout.flush()
+    
+    @staticmethod
+    def spinning_cursor(message="Loading", duration=3.0, delay=0.1, frames=None, clear_before=False):
+        if clear_before:
+            Animate.clear_screen()
+        if frames is None:
+            frames = ["|", "/", "-", "\\"]
+        end_time = time.time() + duration
+        idx = 0
+        while time.time() < end_time:
+            frame = frames[idx % len(frames)]
+            sys.stdout.write(f"\r{message} {frame} ")
+            sys.stdout.flush()
+            time.sleep(delay)
+            idx += 1
+        sys.stdout.write("\r" + " " * (len(message) + 3) + "\r")
+        sys.stdout.flush()
+    
+    @staticmethod
+    def countdown(seconds, message="Countdown", clear_before=False):
+        if clear_before:
+            Animate.clear_screen()
+        for remaining in range(seconds, 0, -1):
+            sys.stdout.write(f"\r{message}: {remaining:2d} seconds remaining ")
+            sys.stdout.flush()
+            time.sleep(1)
+        sys.stdout.write(f"\r{message}: 0 seconds remaining! Done!\n")
+        sys.stdout.flush()
+
+class Keyboard:
+    @staticmethod
+    def GetKey():
+        if os.name == "posix":
+            try:
+                import termios
+                import tty
+                fd = sys.stdin.fileno()
+                old = termios.tcgetattr(fd)
+                try:
+                    tty.setraw(fd)
+                    ch = sys.stdin.read(1)
+                    return ch if ch else ""
+                finally:
+                    termios.tcsetattr(fd, termios.TCSADRAIN, old)
+            except Exception:
+                try:
+                    return sys.stdin.read(1) or ""
+                except Exception:
+                    return ""
+
+        if os.name == "nt":
+            try:
+                import msvcrt
+                ch = msvcrt.getwch()
+                if ch in ("\x00", "\xe0"):
+                    ch2 = msvcrt.getwch()
+                    return "\x1b[" + Keyboard._win_ext_to_ansi(ch2)
+                return ch
+            except Exception:
+                try:
+                    return sys.stdin.read(1) or ""
+                except Exception:
+                    return ""
+
+        try:
+            return sys.stdin.read(1) or ""
+        except Exception:
+            return ""
+
+    @staticmethod
+    def _win_ext_to_ansi(ch):
+        return {
+            "H": "A",
+            "P": "B",
+            "M": "C",
+            "K": "D",
+            "G": "H",
+            "O": "F",
+            "I": "5~",
+            "Q": "6~",
+            "S": "3~",
+            "R": "2~",
+        }.get(ch, "")
+
+    @staticmethod
+    def GetKeyName():
+        k = Keyboard.GetKey()
+        if not k:
+            return ""
+
+        if k == "\x1b":
+            try:
+                k2 = Keyboard.GetKey()
+            except Exception:
+                return "ESC"
+
+            if k2 == "[":
+                try:
+                    k3 = Keyboard.GetKey()
+                except Exception:
+                    return "ESC"
+
+                simple = {
+                    "A": "UP", "B": "DOWN", "C": "RIGHT", "D": "LEFT",
+                    "H": "HOME", "F": "END",
+                }
+                if k3 in simple:
+                    return simple[k3]
+
+                if k3.isdigit():
+                    digits = k3
+                    try:
+                        while len(digits) < 3:
+                            nxt = Keyboard.GetKey()
+                            if not nxt:
+                                break
+                            if nxt == "~":
+                                break
+                            if nxt.isdigit():
+                                digits += nxt
+                            else:
+                                break
+                    except Exception:
+                        pass
+                    return {
+                        "1": "HOME", "2": "INSERT", "3": "DELETE",
+                        "4": "END", "5": "PGUP", "6": "PGDN",
+                        "7": "HOME", "8": "END",
+                        "11": "F1", "12": "F2", "13": "F3", "14": "F4",
+                        "15": "F5", "17": "F6", "18": "F7", "19": "F8",
+                        "20": "F9", "21": "F10", "23": "F11", "24": "F12",
+                    }.get(digits, "ESC")
+
+                if k3 == "1":
+                    try:
+                        Keyboard.GetKey()
+                        Keyboard.GetKey()
+                        arrow = Keyboard.GetKey()
+                        return simple.get(arrow, "ESC")
+                    except Exception:
+                        return "ESC"
+
+                return "ESC"
+
+            if k2 == "O":
+                try:
+                    k3 = Keyboard.GetKey()
+                except Exception:
+                    return "ESC"
+                return {
+                    "A": "UP", "B": "DOWN", "C": "RIGHT", "D": "LEFT",
+                    "H": "HOME", "F": "END",
+                    "P": "F1", "Q": "F2", "R": "F3", "S": "F4",
+                }.get(k3, "ESC")
+
+            return "ESC"
+
+        if k in ("\r", "\n"):
+            return "ENTER"
+        if k in ("\x7f", "\x08"):
+            return "BACKSPACE"
+        if k == "\t":
+            return "TAB"
+        if k == "\x03":
+            return "CTRL_C"
+        if k == "\x04":
+            return "CTRL_D"
+        if k == "\x1a":
+            return "CTRL_Z"
+
+        return k
+
+    @staticmethod
+    def IsRawSupported():
+        if os.name == "nt":
+            try:
+                import msvcrt
+                return True
+            except Exception:
+                return False
+        try:
+            import termios
+            import tty
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+            return True
+        except Exception:
+            return False
+
+    @staticmethod
+    def Flush():
+        try:
+            if os.name == "nt":
+                import msvcrt
+                while msvcrt.kbhit():
+                    msvcrt.getwch()
+            else:
+                import termios
+                fd = sys.stdin.fileno()
+                termios.tcflush(fd, termios.TCIFLUSH)
+        except Exception:
+            pass
+
+class Widget:
+    def __init__(self, x=0, y=0, w=0, h=0):
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.focusable = False
+        self.focused = False
+        self.visible = True
+        self.parent = None
+        self.children = []
+        self.style = None
+
+    def add(self, widget):
+        widget.parent = self
+        self.children.append(widget)
+        return widget
+
+    def remove(self, widget):
+        if widget in self.children:
+            self.children.remove(widget)
+        widget.parent = None
+
+    def draw(self, canvas):
+        for child in self.children:
+            if child.visible:
+                child.draw(canvas)
+
+    def handle_key(self, key):
+        for child in self.children:
+            if child.focused and child.handle_key(key):
+                return True
+        return False
+
+    def handle_mouse(self, event):
+        for child in self.children:
+            if child.contains(event.x, event.y):
+                if child.handle_mouse(event):
+                    return True
+        return False
+
+    def contains(self, x, y):
+        return (self.x <= x < self.x + self.w and
+                self.y <= y < self.y + self.h)
+
+    def move(self, x, y):
+        self.x = x
+        self.y = y
+
+    def resize(self, w, h):
+        self.w = w
+        self.h = h
+
+    def focus(self):
+        self.focused = True
+
+    def blur(self):
+        self.focused = False
+
+class ConsoleInfo:
+    @staticmethod
+    def GetConsole():
+        return sys.stdout
+    
+    @staticmethod
+    def GetPipVer():
+        try:
+            result = CMD.run(['python', '-m', 'pip', '--version'], capture_output=True, text=True, check=True)
+            return result.stdout.strip()
+        except:
+            return "Error: pip not found"
+    @staticmethod
+    def GetSize():
+        import shutil
+        return shutil.get_terminal_size((80, 24))
+    
+    @staticmethod
+    def GetWidth():
+        import shutil
+        return shutil.get_terminal_size((80, 24)).columns
+    
+    @staticmethod
+    def GetHeight():
+        import shutil
+        return shutil.get_terminal_size((80, 24)).lines
+
+class Process:
+    @staticmethod
+    def StartPyCode(code, wait=False, args=None, python="python"):
+        try:
+            cmd = [python, "-c", code]
+            if args:
+                cmd.extend(args)
+            if wait:
+                proc = CMD.run(cmd, capture_output=True, text=True)
+                return proc
+            else:
+                proc = CMD.Popen(cmd)
+                return proc
+        except Exception as e:
+            print(f"Error executing code: {e}")
+            return None
+
+    @staticmethod
+    def KillPyScript(pid):
+        try:
+            os.kill(pid, 15)
+            time.sleep(0.2)
+            return True
+        except ProcessLookupError:
+            print(f"Process {pid} not found")
+            return False
+        except PermissionError:
+            print(f"Permission denied to kill process {pid}")
+            return False
+        except Exception as e:
+            print(f"Error killing process: {e}")
+            return False
+
+    @staticmethod
+    def KillPyScriptForce(pid):
+        try:
+            os.kill(pid, 9)
+            return True
+        except ProcessLookupError:
+            print(f"Process {pid} not found")
+            return False
+        except PermissionError:
+            print(f"Permission denied to kill process {pid}")
+            return False
+        except Exception as e:
+            print(f"Error killing process: {e}")
+            return False
+
+    @staticmethod
+    def IsRunning(pid):
+        try:
+            os.kill(pid, 0)
+            return True
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True
+
+    @staticmethod
+    def GetProcessList():
+        try:
+            result = CMD.run(['ps', '-e', '-o', 'pid,comm'], capture_output=True, text=True)
+            lines = result.stdout.strip().split('\n')[1:]
+            processes = []
+            for line in lines:
+                parts = line.strip().split(' ', 1)
+                if len(parts) == 2:
+                    pid = int(parts[0])
+                    name = parts[1]
+                    processes.append({'pid': pid, 'name': name})
+            return processes
+        except Exception:
+            return []
+
+    @staticmethod
+    def GetProcessInfo(pid):
+        try:
+            result = CMD.run(['ps', '-p', str(pid), '-o', 'pid,comm,%cpu,%mem,etime'], capture_output=True, text=True)
+            lines = result.stdout.strip().split('\n')
+            if len(lines) < 2:
+                return None
+            parts = lines[1].strip().split()
+            if len(parts) >= 5:
+                return {
+                    'pid': int(parts[0]),
+                    'name': parts[1],
+                    'cpu': parts[2],
+                    'memory': parts[3],
+                    'time': parts[4]
+                }
+            return None
+        except Exception:
+            return None
+
+    @staticmethod
+    def WaitForProcess(pid, timeout=None):
+        start_time = time.time()
+        while Process.IsRunning(pid):
+            if timeout and (time.time() - start_time) > timeout:
+                return False
+            time.sleep(0.5)
+        return True
+
+    @staticmethod
+    def GetCurrentPID():
+        return os.getpid()
+
+class Channel:
+    def __init__(self):
+        self.connection = None
+        self.host = None
+        self.port = None
+        self.is_server = False
+
+    @staticmethod
+    def _get(url, timeout=5):
+        try:
+            import urllib.request
+            with urllib.request.urlopen(url, timeout=timeout) as response:
+                return response.read().decode()
+        except Exception:
+            return None
+
+    @staticmethod
+    def GetPublicIP():
+        ip = Channel._get('https://api.ipify.org')
+        return ip
+
+    def Connect(self, host='127.0.0.1', port=54321):
+        self.host = host
+        self.port = port
+        try:
+            self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.connection.connect((host, port))
+            return self.connection
+        except Exception as e:
+            print(f"[Error] Connection failed: {e}")
+            return None
+
+    def ConnectPublic(self, port=54321):
+        public_ip = Channel.GetPublicIP()
+        if not public_ip:
+            print("[Error] Could not get public IP")
+            return None
+        return self.Connect(host=public_ip, port=port)
+
+    def CreateServer(self, port=54321):
+        self.is_server = True
+        self.port = port
+        try:
+            server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            server.bind(('0.0.0.0', port))
+            server.listen(1)
+            self.connection, addr = server.accept()
+            return self.connection
+        except Exception as e:
+            print(f"[Error] Server failed: {e}")
+            return None
+
+    def Disconnect(self):
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+
+    def Send(self, message):
+        if not self.connection:
+            return False
+        try:
+            if isinstance(message, str):
+                message = message.encode()
+            self.connection.send(message + b'\n')
+            return True
+        except Exception:
+            return False
+
+    def Receive(self):
+        if not self.connection:
+            return None
+        try:
+            data = self.connection.recv(1024).decode().strip()
+            return data
+        except Exception:
+            return None
+
+class Web:
+    _server = None
+    _thread = None
+    @staticmethod
+    def StartHTMLCode(html_content, port=None, auto_open=True):
+        if port is None:
+            port = Web._get_free_port()
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):
+                self.send_response(200)
+                self.send_header("Content-type", "text/html")
+                self.end_headers()
+                self.wfile.write(html_content.encode("utf-8"))
+            def log_message(self, format, *args):
+                pass
+        Web._server = HTTPServer(("127.0.0.1", port), Handler)
+        def run_server():
+            print(f"[Web] Server running on http://localhost:{port}")
+            Web._server.serve_forever()
+        Web._thread = threading.Thread(target=run_server, daemon=True)
+        Web._thread.start()
+        if auto_open:
+            webbrowser.open(f"http://localhost:{port}")
+        return port
+
+    @staticmethod
+    def KillHTMLCode():
+        if Web._server is not None:
+            Web._server.shutdown()
+            Web._server.server_close()
+            Web._server = None
+            Web._thread = None
+            return True
+        return False
+
+    @staticmethod
+    def _get_free_port():
+        import socket
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            return s.getsockname()[1]
+
+# ─────────────────────────────────────────────
+# Canvas — fixed-layout buffer for GUI rendering
+# ─────────────────────────────────────────────
+class Canvas:
+    def __init__(self, width, height, fill=' '):
+        self.w = width
+        self.h = height
+        self.buf = [fill] * (width * height)
+        self.fg = {}
+        self.bg = {}
+
+    def clear(self, fill=' '):
+        self.buf = [fill] * (self.w * self.h)
+        self.fg.clear()
+        self.bg.clear()
+
+    def set(self, x, y, char, color=None, bg=None):
+        if 0 <= x < self.w and 0 <= y < self.h:
+            idx = y * self.w + x
+            self.buf[idx] = char[0] if char else ' '
+            if color:
+                self.fg[idx] = color
+            else:
+                self.fg.pop(idx, None)
+            if bg:
+                self.bg[idx] = bg
+            else:
+                self.bg.pop(idx, None)
+
+    def get(self, x, y):
+        if 0 <= x < self.w and 0 <= y < self.h:
+            return self.buf[y * self.w + x]
+        return ' '
+
+    def text(self, x, y, s, color=None, bg=None):
+        for i, ch in enumerate(s):
+            self.set(x + i, y, ch, color, bg)
+
+    def hline(self, x1, x2, y, char='─', color=None, bg=None):
+        if x2 < x1:
+            x1, x2 = x2, x1
+        for x in range(x1, x2 + 1):
+            self.set(x, y, char, color, bg)
+
+    def vline(self, x, y1, y2, char='│', color=None, bg=None):
+        if y2 < y1:
+            y1, y2 = y2, y1
+        for y in range(y1, y2 + 1):
+            self.set(x, y, char, color, bg)
+
+    def rect(self, x1, y1, x2, y2, color=None, bg=None):
+        if x2 < x1:
+            x1, x2 = x2, x1
+        if y2 < y1:
+            y1, y2 = y2, y1
+        self.hline(x1 + 1, x2 - 1, y1, '─', color, bg)
+        self.hline(x1 + 1, x2 - 1, y2, '─', color, bg)
+        self.vline(x1, y1 + 1, y2 - 1, '│', color, bg)
+        self.vline(x2, y1 + 1, y2 - 1, '│', color, bg)
+        self.set(x1, y1, '┌', color, bg)
+        self.set(x2, y1, '┐', color, bg)
+        self.set(x1, y2, '└', color, bg)
+        self.set(x2, y2, '┘', color, bg)
+
+    def fill_rect(self, x1, y1, x2, y2, char=' ', color=None, bg=None):
+        if x2 < x1:
+            x1, x2 = x2, x1
+        if y2 < y1:
+            y1, y2 = y2, y1
+        for y in range(y1, y2 + 1):
+            for x in range(x1, x2 + 1):
+                self.set(x, y, char, color, bg)
+
+    def render(self):
+        lines = []
+        for y in range(self.h):
+            row = []
+            for x in range(self.w):
+                idx = y * self.w + x
+                ch = self.buf[idx]
+                fg = self.fg.get(idx)
+                bg = self.bg.get(idx)
+                if fg or bg:
+                    row.append(f"{fg or ''}{bg or ''}{ch}{Colors.RESET}")
+                else:
+                    row.append(ch)
+            lines.append(''.join(row))
+        return '\n'.join(lines)
+
+
+    def show(self):
+        sys.stdout.write("\033[H")
+        sys.stdout.write(self.render())
+        sys.stdout.write("\033[J")
+        sys.stdout.flush()
+
+class Cursor:
+    @staticmethod
+    def move(x, y):
+        sys.stdout.write(f"\033[{y};{x}H")
+        sys.stdout.flush()
+
+    @staticmethod
+    def up(n=1):
+        sys.stdout.write(f"\033[{n}A")
+        sys.stdout.flush()
+
+    @staticmethod
+    def down(n=1):
+        sys.stdout.write(f"\033[{n}B")
+        sys.stdout.flush()
+
+    @staticmethod
+    def clear_line():
+        sys.stdout.write("\r\033[K")
+        sys.stdout.flush()
+
+    @staticmethod
+    def clear_screen():
+        sys.stdout.write("\033[2J\033[H")
+        sys.stdout.flush()
+
+    @staticmethod
+    def hide():
+        sys.stdout.write("\033[?25l")
+        sys.stdout.flush()
+
+    @staticmethod
+    def show():
+        sys.stdout.write("\033[?25h")
+        sys.stdout.flush()
+
+class Layout:
+    ABSOLUTE = "absolute"
+    VSTACK = "vstack"
+    HSTACK = "hstack"
+    GRID = "grid"
+
+    def __init__(self, mode=ABSOLUTE, padding=0, spacing=0):
+        self.mode = mode
+        self.padding = padding
+        self.spacing = spacing
+        self.children = []
+
+    def add(self, widget, **opts):
+        self.children.append((widget, opts))
+
+    def arrange(self, area):
+        if self.mode == Layout.ABSOLUTE:
+            return  # widgets keep their own x/y
+        if self.mode == Layout.VSTACK:
+            y = area.y + self.padding
+            for w, opts in self.children:
+                h = opts.get("h", w.h)
+                w.x = area.x + self.padding
+                w.y = y
+                w.w = area.w - 2 * self.padding
+                w.h = h
+                y += h + self.spacing
+        elif self.mode == Layout.HSTACK:
+            x = area.x + self.padding
+            for w, opts in self.children:
+                wd = opts.get("w", w.w)
+                w.x = x
+                w.y = area.y + self.padding
+                w.w = wd
+                w.h = area.h - 2 * self.padding
+                x += wd + self.spacing
+        elif self.mode == Layout.GRID:
+            # rows x cols from opts
+            rows = max(opts.get("row", 0) for _, opts in self.children) + 1
+            cols = max(opts.get("col", 0) for _, opts in self.children) + 1
+            cw = (area.w - 2 * self.padding) // cols
+            ch = (area.h - 2 * self.padding) // rows
+            for w, opts in self.children:
+                r, c = opts.get("row", 0), opts.get("col", 0)
+                w.x = area.x + self.padding + c * cw
+                w.y = area.y + self.padding + r * ch
+                w.w = cw
+                w.h = ch
+
+class Container(Widget):
+    def __init__(self, x=0, y=0, w=0, h=0, layout=None):
+        super().__init__(x, y, w, h)
+        self.layout = layout or Layout()
+        self.children = []
+
+    def add(self, widget, **opts):
+        self.children.append(widget)
+        self.layout.add(widget, **opts)
+        return widget
+
+    def remove(self, widget):
+        self.children.remove(widget)
+
+    def draw(self, canvas):
+        self.layout.arrange(Rect(self.x, self.y, self.w, self.h))
+        for child in self.children:
+            if child.visible:
+                child.draw(canvas)
+
+    def handle_key(self, key):
+        for child in self.children:
+            if child.focused and child.handle_key(key):
+                return True
+        return False
+
+class Scrollable(Widget):
+    def __init__(self, x, y, w, h, content=None):
+        super().__init__(x, y, w, h)
+        self.content = content or []   # list of (text, color)
+        self.offset = 0
+        self.total = 0
+        self.focusable = True
+
+    def set_content(self, lines):
+        self.content = lines
+        self.total = len(lines)
+        self.clamp()
+
+    def clamp(self):
+        max_off = max(0, self.total - self.h)
+        self.offset = max(0, min(self.offset, max_off))
+
+    def scroll(self, n):
+        self.offset += n
+        self.clamp()
+
+    def draw(self, canvas):
+        visible = self.content[self.offset:self.offset + self.h]
+        for i, item in enumerate(visible):
+            text, color = item if isinstance(item, tuple) else (item, None)
+            canvas.text(self.x, self.y + i, text[:self.w], color or Colors.WHITE)
+        # scrollbar
+        if self.total > self.h:
+            bar_x = self.x + self.w - 1
+            bar_h = max(1, self.h * self.h // self.total)
+            bar_y = self.y + (self.h - bar_h) * self.offset // max(1, self.total - self.h)
+            for i in range(self.h):
+                canvas.set(bar_x, self.y + i, "│", Colors.DIM)
+            for i in range(bar_h):
+                canvas.set(bar_x, bar_y + i, "█", Colors.CYAN)
+
+    def handle_key(self, key):
+        if key == "UP":
+            self.scroll(-1)
+            return True
+        if key == "DOWN":
+            self.scroll(1)
+            return True
+        if key == "PGUP":
+            self.scroll(-self.h)
+            return True
+        if key == "PGDN":
+            self.scroll(self.h)
+            return True
+        if key == "HOME":
+            self.offset = 0
+            return True
+        if key == "END":
+            self.offset = max(0, self.total - self.h)
+            return True
+        return False
+
+class Label(Widget):
+    def __init__(self, x, y, text, color=None, bg=None):
+        super().__init__(x, y, len(text), 1)
+        self.text = text
+        self.color = color
+        self.bg = bg
+
+    def draw(self, canvas):
+        canvas.text(self.x, self.y, self.text[:self.w], self.color, self.bg)
+
+class Button(Widget):
+    def __init__(self, x, y, text, on_click=None, color=None):
+        super().__init__(x, y, len(text) + 4, 1)
+        self.text = text
+        self.on_click = on_click
+        self.color = color or Colors.CYAN
+        self.focusable = True
+
+    def draw(self, canvas):
+        label = f"[ {self.text} ]"
+        c = (Colors.BG_BLUE + Colors.WHITE) if self.focused else self.color
+        canvas.text(self.x, self.y, label, c)
+
+    def handle_key(self, key):
+        if key == "ENTER" and self.on_click:
+            self.on_click()
+            return True
+        return False
+
+class Menu(Widget):
+    def __init__(self, x, y, items, on_select=None, width=None, color=None):
+        self.items = items
+        self.selected = 0
+        self.on_select = on_select
+        self.color = color or Colors.WHITE
+        w = width or (max(len(l) for _, l in items) + 4)
+        super().__init__(x, y, w, len(items))
+        self.focusable = True
+
+    def draw(self, canvas):
+        for i, (_, label) in enumerate(self.items):
+            y = self.y + i
+            if i == self.selected and self.focused:
+                canvas.fill_rect(self.x, y, self.x + self.w - 1, y, " ",
+                                 Colors.WHITE, Colors.BG_BLUE)
+                canvas.text(self.x + 1, y, f"▸ {label}",
+                            Colors.WHITE + Colors.BOLD, Colors.BG_BLUE)
+            else:
+                canvas.text(self.x + 2, y, label, self.color)
+
+    def handle_key(self, key):
+        if key == "UP":
+            self.selected = (self.selected - 1) % len(self.items)
+            return True
+        if key == "DOWN":
+            self.selected = (self.selected + 1) % len(self.items)
+            return True
+        if key == "ENTER" and self.on_select:
+            self.on_select(self.items[self.selected][0])
+            return True
+        return False
+
+class Panel(Widget):
+    def __init__(self, x, y, w, h, title="", color=None):
+        super().__init__(x, y, w, h)
+        self.title = title
+        self.color = color or Colors.CYAN
+
+    def draw(self, canvas):
+        canvas.rect(self.x, self.y, self.x + self.w - 1,
+                    self.y + self.h - 1, self.color)
+        if self.title:
+            canvas.text(self.x + 2, self.y, f" {self.title} ",
+                        self.color + Colors.BOLD)
+
+class Input(Widget):
+    def __init__(self, x, y, w, prompt="", on_submit=None, color=None):
+        super().__init__(x, y, w, 1)
+        self.prompt = prompt
+        self.buf = ""
+        self.on_submit = on_submit
+        self.color = color or Colors.WHITE
+        self.focusable = True
+
+    def draw(self, canvas):
+        canvas.text(self.x, self.y, self.prompt, Colors.GREEN + Colors.BOLD)
+        px = self.x + len(self.prompt)
+        canvas.text(px, self.y, self.buf[:max(0, self.w - len(self.prompt))],
+                    self.color)
+        cx = px + len(self.buf)
+        if cx < self.x + self.w:
+            canvas.set(cx, self.y, "█", Colors.GREEN)
+
+    def handle_key(self, key):
+        if key == "ENTER":
+            if self.on_submit:
+                self.on_submit(self.buf)
+            self.buf = ""
+            return True
+        if key == "BACKSPACE":
+            self.buf = self.buf[:-1]
+            return True
+        if len(key) == 1 and key >= " ":
+            self.buf += key
+            return True
+        return False
+
+class HeaderBar(Widget):
+    def __init__(self, x, y, w, left="", right="", bg=None, fg=None):
+        super().__init__(x, y, w, 1)
+        self.left = left
+        self.right = right
+        self.bg = bg or Colors.BG_MAGENTA
+        self.fg = fg or Colors.WHITE
+
+    def draw(self, canvas):
+        canvas.fill_rect(self.x, self.y, self.x + self.w - 1, self.y, " ",
+                         self.fg, self.bg)
+        canvas.text(self.x + 1, self.y, self.left,
+                    self.fg + Colors.BOLD, self.bg)
+        rx = self.x + self.w - len(self.right) - 2
+        if rx > self.x + len(self.left) + 2:
+            canvas.text(rx, self.y, self.right, self.fg, self.bg)
+
+class StatusBar(Widget):
+    def __init__(self, x, y, w, left="", mid="", right="", bg=None):
+        super().__init__(x, y, w, 1)
+        self.left = left
+        self.mid = mid
+        self.right = right
+        self.bg = bg or Colors.BG_BLACK
+
+    def draw(self, canvas):
+        canvas.fill_rect(self.x, self.y, self.x + self.w - 1, self.y, " ",
+                         Colors.WHITE, self.bg)
+        canvas.text(self.x, self.y, self.left, Colors.YELLOW, self.bg)
+        canvas.text(self.x + 20, self.y, self.mid, Colors.CYAN, self.bg)
+        rx = self.x + self.w - len(self.right) - 1
+        if rx > self.x:
+            canvas.text(rx, self.y, self.right, Colors.GREEN, self.bg)
+
+class Table(Widget):
+    def __init__(self, x, y, w, h, headers=None, rows=None, color=None):
+        super().__init__(x, y, w, h)
+        self.headers = headers or []
+        self.rows = rows or []
+        self.color = color or Colors.WHITE
+        self.selected = 0
+
+    def draw(self, canvas):
+        n = len(self.headers)
+        if n == 0:
+            return
+        col_w = self.w // n
+        for i, h in enumerate(self.headers):
+            canvas.fill_rect(self.x + i * col_w, self.y,
+                             self.x + (i + 1) * col_w - 1, self.y,
+                             " ", Colors.WHITE, Colors.BG_BLUE)
+            canvas.text(self.x + i * col_w + 1, self.y, h[:col_w - 2],
+                        Colors.WHITE + Colors.BOLD, Colors.BG_BLUE)
+        for r, row in enumerate(self.rows[:self.h - 1]):
+            y = self.y + 1 + r
+            bg = Colors.BG_BLACK if r == self.selected else None
+            fg = Colors.YELLOW if r == self.selected else self.color
+            for i, cell in enumerate(row[:n]):
+                canvas.text(self.x + i * col_w + 1, y, str(cell)[:col_w - 2], fg, bg)
+
+    def handle_key(self, key):
+        if key == "UP":
+            self.selected = max(0, self.selected - 1); return True
+        if key == "DOWN":
+            self.selected = min(len(self.rows) - 1, self.selected + 1); return True
+        return False
+
+class ProgressBar(Widget):
+    def __init__(self, x, y, w, value=0, maximum=100,
+                 fill_char="█", empty_char="░", color=None):
+        super().__init__(x, y, w, 1)
+        self.value = value
+        self.maximum = maximum
+        self.fill_char = fill_char
+        self.empty_char = empty_char
+        self.color = color or Colors.GREEN
+
+    @property
+    def percent(self):
+        if self.maximum <= 0:
+            return 0
+        return max(0.0, min(1.0, self.value / self.maximum))
+
+    def draw(self, canvas):
+        filled = int(self.percent * self.w)
+        canvas.text(self.x, self.y, self.fill_char * filled, self.color)
+        canvas.text(self.x + filled, self.y,
+                    self.empty_char * (self.w - filled), Colors.DIM)
+        label = f"{int(self.percent * 100)}%"
+        lx = self.x + (self.w - len(label)) // 2
+        canvas.text(lx, self.y, label, Colors.WHITE + Colors.BOLD)
+
+    def set(self, value):
+        self.value = value
+
+class Checkbox(Widget):
+    def __init__(self, x, y, text, checked=False, on_toggle=None, color=None):
+        super().__init__(x, y, len(text) + 4, 1)
+        self.text = text
+        self.checked = checked
+        self.on_toggle = on_toggle
+        self.color = color or Colors.WHITE
+        self.focusable = True
+
+    def draw(self, canvas):
+        mark = "[x]" if self.checked else "[ ]"
+        c = Colors.BG_BLUE + Colors.WHITE if self.focused else self.color
+        canvas.text(self.x, self.y, f"{mark} {self.text}", c)
+
+    def handle_key(self, key):
+        if key in ("ENTER", " "):
+            self.checked = not self.checked
+            if self.on_toggle:
+                self.on_toggle(self.checked)
+            return True
+        return False
+
+class RadioGroup(Widget):
+    def __init__(self, x, y, options, selected=0, on_change=None, color=None):
+        super().__init__(x, y, max(len(o) for o in options) + 4, len(options))
+        self.options = options
+        self.selected = selected
+        self.on_change = on_change
+        self.color = color or Colors.WHITE
+        self.focusable = True
+
+    def draw(self, canvas):
+        for i, opt in enumerate(self.options):
+            mark = "(o)" if i == self.selected else "( )"
+            c = Colors.BG_BLUE + Colors.WHITE if self.focused else self.color
+            canvas.text(self.x, self.y + i, f"{mark} {opt}", c)
+
+    def handle_key(self, key):
+        if key == "UP":
+            self.selected = (self.selected - 1) % len(self.options)
+            if self.on_change: self.on_change(self.selected)
+            return True
+        if key == "DOWN":
+            self.selected = (self.selected + 1) % len(self.options)
+            if self.on_change: self.on_change(self.selected)
+            return True
+        return False
+
+class MessageBox(Widget):
+    ICONS = {
+        "info":     ("i", Colors.BLUE),
+        "warning":  ("!", Colors.YELLOW),
+        "error":    ("x", Colors.RED),
+        "question": ("?", Colors.CYAN),
+    }
+
+    def __init__(self, canvas, title, message,
+                 kind="info",
+                 buttons=("OK",),
+                 on_result=None):
+        self.canvas_ref = canvas
+        self.title = title
+        self.message = message
+        self.kind = kind
+        self.buttons = list(buttons)
+        self.on_result = on_result
+        self.result = None
+        self.selected = 0
+        self.done = False
+
+        W = canvas.w
+        H = canvas.h
+
+        msg_lines = message.split("\n")
+        msg_w = max(len(l) for l in msg_lines) if msg_lines else 0
+        icon_w = 4
+        btn_w = sum(len(b) + 4 for b in self.buttons) + 2 * (len(self.buttons) - 1)
+        content_w = max(msg_w, btn_w) + icon_w + 6
+        w = min(W - 4, max(40, content_w))
+        h = 6 + len(msg_lines)
+        x = (W - w) // 2
+        y = (H - h) // 2
+
+        super().__init__(x, y, w, h)
+        self.focusable = True
+
+    def draw(self, canvas):
+        x, y, w, h = self.x, self.y, self.w, self.h
+
+        canvas.fill_rect(x, y, x + w - 1, y + h - 1, " ",
+                         Colors.WHITE, Colors.BG_BLACK)
+        canvas.rect(x, y, x + w - 1, y + h - 1, Colors.CYAN)
+
+        title = f" {self.title} "
+        canvas.text(x + 2, y, title, Colors.CYAN + Colors.BOLD)
+
+        icon_ch, icon_color = self.ICONS.get(self.kind, ("i", Colors.BLUE))
+        canvas.text(x + 3, y + 2, f" {icon_ch} ", icon_color + Colors.BOLD)
+
+        for i, line in enumerate(self.message.split("\n")):
+            canvas.text(x + 6, y + 2 + i, line[:w - 8], Colors.WHITE)
+
+        btn_y = y + h - 2
+        total = sum(len(b) + 4 for b in self.buttons) + 2 * (len(self.buttons) - 1)
+        bx = x + (w - total) // 2
+        for i, label in enumerate(self.buttons):
+            txt = f"[ {label} ]"
+            if i == self.selected:
+                c = Colors.WHITE + Colors.BOLD
+                bg = Colors.BG_BLUE
+                canvas.fill_rect(bx, btn_y, bx + len(txt) - 1, btn_y, " ", c, bg)
+                canvas.text(bx, btn_y, txt, c, bg)
+            else:
+                canvas.text(bx, btn_y, txt, Colors.WHITE)
+            bx += len(txt) + 2
+
+    def handle_key(self, key):
+        if key == "LEFT":
+            self.selected = (self.selected - 1) % len(self.buttons)
+            return True
+        if key == "RIGHT":
+            self.selected = (self.selected + 1) % len(self.buttons)
+            return True
+        if key == "TAB":
+            self.selected = (self.selected + 1) % len(self.buttons)
+            return True
+        if key == "ENTER":
+            self.result = self.buttons[self.selected]
+            self.done = True
+            if self.on_result:
+                self.on_result(self.result)
+            return True
+        if key == "ESC":
+            self.result = self.buttons[-1]
+            self.done = True
+            if self.on_result:
+                self.on_result(self.result)
+            return True
+        return False
+
+    @staticmethod
+    def _modal_loop(canvas, box):
+        while not box.done:
+            box.draw(canvas)
+            canvas.show()
+            key = Keyboard.GetKeyName()
+            if key == "CTRL_C":
+                box.result = box.buttons[-1]
+                box.done = True
+                break
+            box.handle_key(key)
+        return box.result
+
+    @staticmethod
+    def showinfo(canvas, title, message):
+        box = MessageBox(canvas, title, message,
+                         kind="info", buttons=("OK",))
+        return MessageBox._modal_loop(canvas, box)
+
+    @staticmethod
+    def showwarning(canvas, title, message):
+        box = MessageBox(canvas, title, message,
+                         kind="warning", buttons=("OK",))
+        return MessageBox._modal_loop(canvas, box)
+
+    @staticmethod
+    def showerror(canvas, title, message):
+        box = MessageBox(canvas, title, message,
+                         kind="error", buttons=("OK",))
+        return MessageBox._modal_loop(canvas, box)
+
+    @staticmethod
+    def askyesno(canvas, title, message):
+        box = MessageBox(canvas, title, message,
+                         kind="question", buttons=("Yes", "No"))
+        return MessageBox._modal_loop(canvas, box) == "Yes"
+
+    @staticmethod
+    def askokcancel(canvas, title, message):
+        box = MessageBox(canvas, title, message,
+                         kind="question", buttons=("OK", "Cancel"))
+        return MessageBox._modal_loop(canvas, box) == "OK"
+
+    @staticmethod
+    def askretrycancel(canvas, title, message):
+        box = MessageBox(canvas, title, message,
+                         kind="warning", buttons=("Retry", "Cancel"))
+        return MessageBox._modal_loop(canvas, box) == "Retry"
+
+    @staticmethod
+    def ask(canvas, title, message, kind="info", buttons=("OK",)):
+        box = MessageBox(canvas, title, message,
+                         kind=kind, buttons=buttons)
+        return MessageBox._modal_loop(canvas, box)
+
+class EventBus:
+    def __init__(self):
+        self._handlers = {}
+
+    def on(self, event, handler):
+        self._handlers.setdefault(event, []).append(handler)
+
+    def off(self, event, handler):
+        if event in self._handlers and handler in self._handlers[event]:
+            self._handlers[event].remove(handler)
+
+    def emit(self, event, *args, **kwargs):
+        for h in self._handlers.get(event, []):
+            try:
+                h(*args, **kwargs)
+            except Exception:
+                pass
+
+    def clear(self, event=None):
+        if event is None:
+            self._handlers.clear()
+        else:
+            self._handlers.pop(event, None)
+
+class FocusManager:
+    def __init__(self):
+        self.stack = []
+
+    def register(self, widget):
+        if widget.focusable and widget not in self.stack:
+            self.stack.append(widget)
+
+    def unregister(self, widget):
+        if widget in self.stack:
+            self.stack.remove(widget)
+
+    def next(self):
+        if not self.stack:
+            return
+        current = next((w for w in self.stack if w.focused), None)
+        idx = (self.stack.index(current) + 1) % len(self.stack) if current else 0
+        self._set(self.stack[idx])
+
+    def prev(self):
+        if not self.stack:
+            return
+        current = next((w for w in self.stack if w.focused), None)
+        idx = (self.stack.index(current) - 1) % len(self.stack) if current else 0
+        self._set(self.stack[idx])
+
+    def set(self, widget):
+        self._set(widget)
+
+    def _set(self, widget):
+        for w in self.stack:
+            w.focused = (w is widget)
+
+class Style:
+    def __init__(self,
+                 fg=None, bg=None,
+                 header_bg=None, header_fg=None,
+                 menu_bg=None, menu_fg=None,
+                 menu_sel_bg=None, menu_sel_fg=None,
+                 input_fg=None, input_bg=None,
+                 status_bg=None, status_fg=None):
+        self.fg = fg or Colors.WHITE
+        self.bg = bg or Colors.BG_BLACK
+        self.header_bg = header_bg or Colors.BG_MAGENTA
+        self.header_fg = header_fg or Colors.WHITE
+        self.menu_bg = menu_bg or Colors.BG_BLACK
+        self.menu_fg = menu_fg or Colors.WHITE
+        self.menu_sel_bg = menu_sel_bg or Colors.BG_BLUE
+        self.menu_sel_fg = menu_sel_fg or Colors.WHITE
+        self.input_fg = input_fg or Colors.WHITE
+        self.input_bg = input_bg or Colors.BG_BLACK
+        self.status_bg = status_bg or Colors.BG_BLACK
+        self.status_fg = status_fg or Colors.CYAN
+
+
+DEFAULT_STYLE = Style()
+
+DARK_STYLE = Style(
+    bg=Colors.BG_BLACK, fg=Colors.WHITE,
+    header_bg=Colors.BG_BLUE, header_fg=Colors.WHITE,
+    menu_bg=Colors.BG_BLACK, menu_fg=Colors.WHITE,
+    menu_sel_bg=Colors.BG_MAGENTA, menu_sel_fg=Colors.WHITE,
+)
+
+LIGHT_STYLE = Style(
+    bg=Colors.BG_WHITE, fg=Colors.BLACK,
+    header_bg=Colors.BG_BLUE, header_fg=Colors.WHITE,
+    menu_bg=Colors.BG_WHITE, menu_fg=Colors.BLACK,
+    menu_sel_bg=Colors.BG_CYAN, menu_sel_fg=Colors.BLACK,
+)
+
+class Theme:
+    current = DEFAULT_STYLE
+
+    @staticmethod
+    def set(style):
+        Theme.current = style
+
+    @staticmethod
+    def get():
+        return Theme.current
+
+class MouseEvent:
+    def __init__(self, x, y, button, pressed):
+        self.x = x
+        self.y = y
+        self.button = button
+        self.pressed = pressed
+
+    def __repr__(self):
+        state = "press" if self.pressed else "release"
+        return f"MouseEvent({self.x},{self.y},{self.button},{state})"
+
+class Mouse:
+    @staticmethod
+    def enable():
+        sys.stdout.write("\033[?1000h\033[?1006h")
+        sys.stdout.flush()
+
+    @staticmethod
+    def disable():
+        sys.stdout.write("\033[?1000l\033[?1006l")
+        sys.stdout.flush()
+
+    @staticmethod
+    def parse(seq):
+        m = re.match(r"\x1b\[<(\d+);(\d+);(\d+)([Mm])", seq)
+        if not m:
+            return None
+        b = int(m.group(1))
+        x = int(m.group(2)) - 1
+        y = int(m.group(3)) - 1
+        kind = m.group(4)
+        pressed = (kind == "M")
+
+        if b & 64:
+            button = "wheel_up" if (b & 1) == 0 else "wheel_down"
+        elif (b & 3) == 0:
+            button = "left"
+        elif (b & 3) == 1:
+            button = "middle"
+        elif (b & 3) == 2:
+            button = "right"
+        else:
+            button = "release"
+
+        return MouseEvent(x, y, button, pressed)
+
+class RenderWidget(Widget):
+    def __init__(self, x, y, w, h):
+        super().__init__(x, y, w, h)
+        self.points = []
+
+    def set_points(self, points):
+        self.points = list(points)
+
+    def add_points(self, points):
+        self.points.extend(points)
+
+    def clear_points(self):
+        self.points = []
+
+    def draw(self, canvas):
+        for item in self.points:
+            if len(item) >= 3:
+                px, py, ch = item[0], item[1], item[2]
+                color = item[3] if len(item) >= 4 else None
+                bg = item[4] if len(item) >= 5 else None
+                if 0 <= px < self.w and 0 <= py < self.h:
+                    canvas.set(self.x + px, self.y + py, ch, color, bg)
+
+class Chart(RenderWidget):
+    def __init__(self, x, y, w, h, color=None):
+        super().__init__(x, y, w, h)
+        self.data = []
+        self.color = color or Colors.GREEN
+
+    def set_data(self, data):
+        self.data = list(data)
+        self._rebuild()
+
+    def _rebuild(self):
+        self.points = []
+        if not self.data:
+            return
+        n = len(self.data)
+        mn = min(self.data)
+        mx = max(self.data)
+        rng = mx - mn or 1
+        for i, v in enumerate(self.data):
+            px = int(i * (self.w - 1) / max(1, n - 1))
+            py = self.h - 1 - int((v - mn) * (self.h - 1) / rng)
+            self.points.append((px, py, "•", self.color))
+
+    def draw(self, canvas):
+        super().draw(canvas)
+
+class App:
+    def __init__(self, width=None, height=None):
+        self.widgets = []
+        self.focus_index = -1
+        self.running = False
+        self.running = False
+        self.events = EventBus()
+        self.focus_mgr = FocusManager()
+        self.style = Theme.current
+        self.width = width
+        self.height = height
+        self.canvas = None
+        self.overlay = None
+
+    # ── widget management ──
+    def add(self, widget):
+        self.widgets.append(widget)
+        if widget.focusable:
+            self.focus_mgr.register(widget)
+        return widget
+
+    def remove(self, widget):
+        if widget in self.widgets:
+            self.widgets.remove(widget)
+        self.focus_mgr.unregister(widget)
+
+    def clear(self):
+        self.widgets = []
+        self.focus_mgr.stack = []
+
+    def focus(self, widget):
+        self.focus_mgr.set(widget)
+
+    def focus_next(self):
+        self.focus_mgr.next()
+
+    def focus_prev(self):
+        self.focus_mgr.prev()
+
+    # ── overlay (modal dialogs) ──
+    def push_overlay(self, widget):
+        self.overlay = widget
+        if widget.focusable:
+            self.focus_mgr.set(widget)
+
+    def pop_overlay(self):
+        self.overlay = None
+
+    # ── rendering ──
+    def size(self):
+        W = self.width or ConsoleInfo.GetWidth()
+        H = self.height or ConsoleInfo.GetHeight()
+        return W, H
+
+    def draw(self):
+        W, H = self.size()
+        canvas = Canvas(W, H)
+        canvas.fill_rect(0, 0, W - 1, H - 1, " ",
+                         self.style.fg, self.style.bg)
+        self.canvas = canvas
+        for w in self.widgets:
+            if w.visible:
+                w.draw(canvas)
+        if self.overlay is not None:
+            self.overlay.draw(canvas)
+        return canvas
+
+    def redraw(self):
+        c = self.draw()
+        c.show()
+
+    # ── event loop ──
+    def handle_key(self, key):
+        if self.overlay is not None:
+            if self.overlay.handle_key(key):
+                if getattr(self.overlay, "done", False):
+                    self.pop_overlay()
+                return True
+            return False
+
+        if key == "TAB":
+            self.focus_next()
+            return True
+        if key == "SHIFT_TAB":
+            self.focus_prev()
+            return True
+
+        for w in self.widgets:
+            if w.focused and w.handle_key(key):
+                return True
+        return False
+
+    def run(self, on_key=None, on_tick=None, tick_interval=0.05):
+        self.running = True
+        Cursor.hide()
+        try:
+            while self.running:
+                self.redraw()
+                key = Keyboard.GetKeyName()
+                if key in ("CTRL_C", "CTRL_D"):
+                    break
+                if on_key and on_key(key):
+                    continue
+                self.handle_key(key)
+                if on_tick:
+                    on_tick()
+        finally:
+            Cursor.show()
+
+    def quit(self):
+        self.running = False