ProGradientTool.py

import sys
import math
import json
import random
from PySide6.QtWidgets import (QApplication, QWidget, QVBoxLayout, QHBoxLayout, 
                               QPushButton, QLabel, QListWidget, QListWidgetItem, 
                               QSlider, QSpinBox, QDoubleSpinBox, QFileDialog, 
                               QGroupBox, QSplitter, QMessageBox, QComboBox, QCheckBox, 
                               QMainWindow, QMenu, QGridLayout, QScrollArea, QFrame, 
                               QLineEdit)
from PySide6.QtGui import QAction, QPainter, QColor, QImage, QIcon, QPixmap, QPen, QPainterPath
from PySide6.QtCore import Qt, Signal, QPoint, QPointF, QDateTime, QSize 

# === CONSTANTS ===
SNES_WIDTH = 256
SNES_HEIGHT = 224

# === MATH HELPERS ===

def clamp(val, min_val=0.0, max_val=1.0):
    return max(min_val, min(max_val, val))

def srgb_to_linear(x):
    return ((x + 0.055) / 1.055) ** 2.4 if x >= 0.04045 else x / 12.92

def linear_to_srgb(x):
    return 1.055 * (x ** (1.0 / 2.4)) - 0.055 if x >= 0.0031308 else 12.92 * x

# --- Oklab / Oklch ---
def rgb_to_oklab(r, g, b):
    lr, lg, lb = srgb_to_linear(r), srgb_to_linear(g), srgb_to_linear(b)
    l = 0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb
    m = 0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb
    s = 0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb
    l_, m_, s_ = l**(1/3), m**(1/3), s**(1/3)
    L = 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_
    a = 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_
    b_val = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_
    return L, a, b_val

def oklab_to_rgb(L, a, b_val):
    l_ = L + 0.3963377774 * a + 0.2158037573 * b_val
    m_ = L - 0.1055613458 * a - 0.0638541728 * b_val
    s_ = L - 0.0894841775 * a - 1.2914855480 * b_val
    l, m, s = l_**3, m_**3, s_**3
    lr = +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s
    lg = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s
    lb = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
    return linear_to_srgb(lr), linear_to_srgb(lg), linear_to_srgb(lb)

def rgb_to_oklch(r, g, b):
    L, a, b_val = rgb_to_oklab(r, g, b)
    C = math.sqrt(a**2 + b_val**2)
    h = math.degrees(math.atan2(b_val, a))
    return L, C, h

def oklch_to_rgb(L, C, h):
    h_rad = math.radians(h)
    a = C * math.cos(h_rad)
    b_val = C * math.sin(h_rad)
    return oklab_to_rgb(L, a, b_val)

# --- CIELAB / CIELCH ---
def rgb_to_cielab(r, g, b):
    lr, lg, lb = srgb_to_linear(r), srgb_to_linear(g), srgb_to_linear(b)
    X = lr * 0.4124 + lg * 0.3576 + lb * 0.1805
    Y = lr * 0.2126 + lg * 0.7152 + lb * 0.0722
    Z = lr * 0.0193 + lg * 0.1192 + lb * 0.9505
    Xn, Yn, Zn = 0.95047, 1.00000, 1.08883
    def f(t): return t**(1/3) if t > 0.008856 else 7.787*t + 16/116
    fx, fy, fz = f(X/Xn), f(Y/Yn), f(Z/Zn)
    L = 116 * fy - 16
    a = 500 * (fx - fy)
    b_val = 200 * (fy - fz)
    return L, a, b_val

def cielab_to_rgb(L, a, b_val):
    def f_inv(t): return t**3 if t > 0.20689 else (t - 16/116) / 7.787
    fy = (L + 16) / 116
    fx = a / 500 + fy
    fz = fy - b_val / 200
    X = 0.95047 * f_inv(fx)
    Y = 1.00000 * f_inv(fy)
    Z = 1.08883 * f_inv(fz)
    lr = X *  3.2406 + Y * -1.5372 + Z * -0.4986
    lg = X * -0.9689 + Y *  1.8758 + Z *  0.0415
    lb = X *  0.0557 + Y * -0.2040 + Z *  1.0570
    return linear_to_srgb(lr), linear_to_srgb(lg), linear_to_srgb(lb)

def rgb_to_cielch(r, g, b):
    L, a, b_val = rgb_to_cielab(r, g, b)
    C = math.sqrt(a**2 + b_val**2)
    h = math.degrees(math.atan2(b_val, a))
    return L, C, h

def cielch_to_rgb(L, C, h):
    h_rad = math.radians(h)
    a = C * math.cos(h_rad)
    b_val = C * math.sin(h_rad)
    return cielab_to_rgb(L, a, b_val)

# --- Standard Easing Functions ---
def ease_linear(t): return t
def ease_in_quad(t): return t * t
def ease_out_quad(t): return t * (2 - t)
def ease_in_out_sine(t): return -(math.cos(math.pi * t) - 1) / 2
def ease_smoothstep(t): return t * t * (3 - 2 * t)
def ease_smootherstep(t): return t * t * t * (t * (t * 6 - 15) + 10)

EASING_FUNCS = {
    "Linear": ease_linear,
    "Ease In (Quad)": ease_in_quad,
    "Ease Out (Quad)": ease_out_quad,
    "Ease In/Out (Sine)": ease_in_out_sine,
    "SmoothStep": ease_smoothstep,
    "SmootherStep": ease_smootherstep
}

# --- Cubic Bezier Solver ---
def solve_cubic_bezier(t_x, p1x, p2x, epsilon=1e-5):
    t = t_x 
    for _ in range(8):
        cx = 3 * p1x
        bx = 3 * (p2x - p1x) - cx
        ax = 1 - cx - bx
        x_est = (ax * t**3) + (bx * t**2) + (cx * t)
        d_x = (3 * ax * t**2) + (2 * bx * t) + cx
        if abs(d_x) < epsilon: break
        diff = x_est - t_x
        if abs(diff) < epsilon: return t
        t = t - diff / d_x
    return max(0.0, min(1.0, t))

def get_cubic_bezier_y(t, p1y, p2y):
    cy = 3 * p1y
    by = 3 * (p2y - p1y) - cy
    ay = 1 - cy - by
    return (ay * t**3) + (by * t**2) + (cy * t)

def eval_custom_curve(progress, p1, p2):
    t_sol = solve_cubic_bezier(progress, p1[0], p2[0])
    return get_cubic_bezier_y(t_sol, p1[1], p2[1])

# --- NEW COLOR SPACES ---

# 1. YIQ (NTSC)
def rgb_to_yiq(r, g, b):
    y = 0.299 * r + 0.587 * g + 0.114 * b
    i = 0.596 * r - 0.274 * g - 0.322 * b
    q = 0.211 * r - 0.523 * g + 0.312 * b
    return y, i, q

def yiq_to_rgb(y, i, q):
    r = y + 0.956 * i + 0.621 * q
    g = y - 0.272 * i - 0.647 * q
    b = y - 1.106 * i + 1.703 * q
    return clamp(r), clamp(g), clamp(b)

# 2. YDbDr (SECAM)
def rgb_to_ydbdr(r, g, b):
    y = 0.299 * r + 0.587 * g + 0.114 * b
    db = -0.450 * r - 0.883 * g + 1.333 * b
    dr = -1.333 * r + 1.116 * g + 0.217 * b
    return y, db, dr

def ydbdr_to_rgb(y, db, dr):
    r_ = y - 0.526 * dr
    g_ = y - 0.129 * db + 0.268 * dr
    b_ = y + 0.665 * db
    return clamp(r_), clamp(g_), clamp(b_)

# 3. CMY (Subtractive)
def rgb_to_cmy(r, g, b):
    return 1.0 - r, 1.0 - g, 1.0 - b

def cmy_to_rgb(c, m, y):
    return clamp(1.0 - c), clamp(1.0 - m), clamp(1.0 - y)

# 4. IPT (Perceptual)
def rgb_to_ipt(r, g, b):
    # RGB -> LMS (Hunt-Pointer-Estevez)
    l = 0.4002 * r + 0.4431 * g + 0.2044 * b
    m = 0.2403 * r + 0.5228 * g + 0.2539 * b
    s = 0.0000 * r + 0.0000 * g + 1.0890 * b
    
    # Non-linearity
    l_ = l ** 0.43 if l > 0 else 0
    m_ = m ** 0.43 if m > 0 else 0
    s_ = s ** 0.43 if s > 0 else 0
    
    # LMS -> IPT
    I = 0.4000 * l_ + 0.4000 * m_ + 0.2000 * s_
    P = 4.4550 * l_ - 4.8510 * m_ + 0.3960 * s_
    T = 0.8056 * l_ + 0.3572 * m_ - 1.1628 * s_
    return I, P, T

def ipt_to_rgb(I, P, T):
    l_ = I + 0.097569 * P + 0.205226 * T
    m_ = I - 0.113880 * P + 0.133217 * T
    s_ = I + 0.032615 * P - 0.676890 * T
    
    def inv_nl(x): return x ** (1/0.43) if x > 0 else 0
    l, m, s = inv_nl(l_), inv_nl(m_), inv_nl(s_)
    
    r = 5.432622 * l - 4.67910 * m + 0.246257 * s
    g = -1.10517 * l + 2.311198 * m - 0.20588 * s
    b = 0.028104 * l - 0.19466 * m + 1.166325 * s
    return clamp(r), clamp(g), clamp(b)

# 5. xyY (CIE 1931)
def rgb_to_xyy(r, g, b):
    lr, lg, lb = srgb_to_linear(r), srgb_to_linear(g), srgb_to_linear(b)
    X = lr * 0.4124 + lg * 0.3576 + lb * 0.1805
    Y = lr * 0.2126 + lg * 0.7152 + lb * 0.0722
    Z = lr * 0.0193 + lg * 0.1192 + lb * 0.9505
    sum_xyz = X + Y + Z
    if sum_xyz == 0: return 0.3127, 0.3290, 0.0 
    x = X / sum_xyz
    y = Y / sum_xyz
    return x, y, Y

def xyy_to_rgb(x, y, Y):
    if y == 0: return 0,0,0
    X = (Y / y) * x
    Z = (Y / y) * (1 - x - y)
    lr = X *  3.2406 + Y * -1.5372 + Z * -0.4986
    lg = X * -0.9689 + Y *  1.8758 + Z *  0.0415
    lb = X *  0.0557 + Y * -0.2040 + Z *  1.0570
    return linear_to_srgb(lr), linear_to_srgb(lg), linear_to_srgb(lb)

# Existing conversions
def rgb_to_xyz(r, g, b):
    lr, lg, lb = srgb_to_linear(r), srgb_to_linear(g), srgb_to_linear(b)
    X = lr * 0.4124564 + lg * 0.3575761 + lb * 0.1804375
    Y = lr * 0.2126729 + lg * 0.7151522 + lb * 0.0721750
    Z = lr * 0.0193339 + lg * 0.1191920 + lb * 0.9503041
    return X, Y, Z

def xyz_to_rgb(X, Y, Z):
    lr =  X *  3.2404542 + Y * -1.5371385 + Z * -0.4985314
    lg =  X * -0.9692660 + Y *  1.8760108 + Z *  0.0415560
    lb =  X *  0.0556434 + Y * -0.2040259 + Z *  1.0572252
    return linear_to_srgb(lr), linear_to_srgb(lg), linear_to_srgb(lb)

def rgb_to_cieluv(r, g, b):
    X, Y, Z = rgb_to_xyz(r, g, b)
    Xn, Yn, Zn = 0.95047, 1.00000, 1.08883
    den = (X + 15 * Y + 3 * Z)
    u_prime = (4 * X) / den if den > 0 else 0
    v_prime = (9 * Y) / den if den > 0 else 0
    dn = (Xn + 15 * Yn + 3 * Zn)
    u_prime_n = (4 * Xn) / dn
    v_prime_n = (9 * Yn) / dn
    
    y_ratio = Y / Yn
    L = 116 * (y_ratio ** (1/3)) - 16 if y_ratio > 0.008856 else 903.3 * y_ratio
    u = 13 * L * (u_prime - u_prime_n)
    v = 13 * L * (v_prime - v_prime_n)
    return L, u, v

def cieluv_to_rgb(L, u, v):
    Xn, Yn, Zn = 0.95047, 1.00000, 1.08883
    dn = (Xn + 15 * Yn + 3 * Zn)
    u_prime_n = (4 * Xn) / dn
    v_prime_n = (9 * Yn) / dn
    
    if L <= 0: return 0.0, 0.0, 0.0
    
    u_prime = (u / (13 * L)) + u_prime_n
    v_prime = (v / (13 * L)) + v_prime_n
    
    Y = Yn * ((L + 16) / 116) ** 3 if L > 8 else Yn * L / 903.3
    X = Y * (9 * u_prime) / (4 * v_prime) if v_prime > 0 else 0
    Z = Y * (12 - 3 * u_prime - 20 * v_prime) / (4 * v_prime) if v_prime > 0 else 0
    return xyz_to_rgb(X, Y, Z)

def rgb_to_cielchuv(r, g, b):
    L, u, v = rgb_to_cieluv(r, g, b)
    C = math.sqrt(u**2 + v**2)
    h = math.degrees(math.atan2(v, u))
    return L, C, h

def cielchuv_to_rgb(L, C, h):
    h_rad = math.radians(h)
    u = C * math.cos(h_rad)
    v = C * math.sin(h_rad)
    return cieluv_to_rgb(L, u, v)

def rgb_to_ycbcr(r, g, b):
    Y  =  0.299    * r + 0.587    * g + 0.114    * b
    Cb = -0.168736 * r - 0.331264 * g + 0.5      * b
    Cr =  0.5      * r - 0.418688 * g - 0.081312 * b
    return Y, Cb, Cr

def ycbcr_to_rgb(Y, Cb, Cr):
    r = Y + 1.402 * Cr
    g = Y - 0.344136 * Cb - 0.714136 * Cr
    b = Y + 1.772 * Cb
    return clamp(r), clamp(g), clamp(b)

def rgb_to_ypbpr(r, g, b):
    Y  =  0.299  * r + 0.587  * g + 0.114  * b
    Pb = -0.169  * r - 0.331  * g + 0.5    * b
    Pr =  0.5    * r - 0.419  * g - 0.081  * b
    return Y, Pb, Pr

def ypbpr_to_rgb(Y, Pb, Pr):
    r = Y + 1.402 * Pr
    g = Y - 0.344 * Pb - 0.714 * Pr
    b = Y + 1.772 * Pb
    return clamp(r), clamp(g), clamp(b)

def rgb_to_hwb(r, g, b):
    c = QColor.fromRgbF(r, g, b)
    h = c.hueF()
    v = c.valueF()
    s = c.saturationF()
    w = v * (1 - s)
    bl = 1 - v
    return h, w, bl

def hwb_to_rgb(h, w, bl):
    if w + bl >= 1:
        gray = w / (w + bl)
        return gray, gray, gray
    v = 1 - bl
    s = 1 - (w / v) if v > 0 else 0
    c = QColor.fromHsvF(max(0, min(1, h)), max(0, min(1, s)), max(0, min(1, v)))
    return c.redF(), c.greenF(), c.blueF()

def rgb_to_lms(r, g, b):
    lr, lg, lb = srgb_to_linear(r), srgb_to_linear(g), srgb_to_linear(b)
    L = 0.3897 * lr + 0.6890 * lg - 0.0787 * lb
    M = -0.2298 * lr + 1.1834 * lg + 0.0464 * lb
    S = 0.0000 * lr + 0.0000 * lg + 1.0000 * lb
    return L, M, S

def lms_to_rgb(L, M, S):
    lr =  1.9102 * L - 1.1121 * M + 0.2019 * S
    lg =  0.3710 * L + 0.6291 * M + 0.0000 * S
    lb =  0.0000 * L + 0.0000 * M + 1.0000 * S
    return linear_to_srgb(lr), linear_to_srgb(lg), linear_to_srgb(lb)


# === DITHER PATTERNS ===

DITHER_MATRICES = {
    "Bayer 2x2": {
        "size": 2,
        "data": [0, 2, 3, 1]
    },
    "Bayer 4x4": {
        "size": 4,
        "data": [
             0,  8,  2, 10,
            12,  4, 14,  6,
             3, 11,  1,  9,
            15,  7, 13,  5
        ]
    },
    "Bayer 8x8": {
        "size": 8,
        "data": [
             0, 32,  8, 40,  2, 34, 10, 42,
            48, 16, 56, 24, 50, 18, 58, 26,
            12, 44,  4, 36, 14, 46,  6, 38,
            60, 28, 52, 20, 62, 30, 54, 22,
             3, 35, 11, 43,  1, 33,  9, 41,
            51, 19, 59, 27, 49, 17, 57, 25,
            15, 47,  7, 39, 13, 45,  5, 37,
            63, 31, 55, 23, 61, 29, 53, 21
        ]
    },
    "Cluster 4x4": {
        "size": 4,
        "data": [
            12, 5,  6, 13,
             4, 0,  1,  7,
            11, 3,  2,  8,
            15, 10, 9, 14
        ]
    }
}

# === 1. Custom 5-Bit Color Picker ===
class SnesColorPicker(QWidget):
    colorChanged = Signal(int, int, int) 
    def __init__(self):
        super().__init__()
        self.setFixedSize(200, 200)
        self.h, self.s, self.v = 0.0, 1.0, 1.0
        self.r5, self.g5, self.b5 = 31, 0, 0
        self.dragging_sv = False
        self.dragging_h = False
        self.RENDER_SIZE = 32 
        self.cached_square = None
        self.cached_hue_bar = None
        self.last_hue_for_square = -1

    def set_color_5bit(self, r, g, b):
        self.r5, self.g5, self.b5 = r, g, b
        c = QColor(int(r/31*255), int(g/31*255), int(b/31*255))
        self.h = max(0, c.hue())
        self.s = c.saturationF()
        self.v = c.valueF()
        self.update()

    def quantize_color(self, c):
        r5 = int((c.red() / 255.0) * 31)
        g5 = int((c.green() / 255.0) * 31)
        b5 = int((c.blue() / 255.0) * 31)
        return QColor(r5 << 3, g5 << 3, b5 << 3)

    def paintEvent(self, event):
        painter = QPainter(self)
        square_rect = self.rect().adjusted(5, 5, -5, -35)
        hue_rect = self.rect().adjusted(5, square_rect.height() + 10, -5, -5)
        if self.cached_hue_bar is None:
            self.cached_hue_bar = QImage(self.RENDER_SIZE, 1, QImage.Format_RGB32)
            for x in range(self.RENDER_SIZE):
                hue = (x / self.RENDER_SIZE) * 360.0
                raw_c = QColor.fromHsvF(hue/360.0, 1.0, 1.0)
                self.cached_hue_bar.setPixelColor(x, 0, self.quantize_color(raw_c))
        painter.drawImage(hue_rect, self.cached_hue_bar.scaled(hue_rect.size(), Qt.IgnoreAspectRatio, Qt.FastTransformation))

        if (self.cached_square is None or abs(self.h - self.last_hue_for_square) > 0.5):
            self.last_hue_for_square = self.h
            self.cached_square = QImage(self.RENDER_SIZE, self.RENDER_SIZE, QImage.Format_RGB32)
            for y in range(self.RENDER_SIZE):
                val = 1.0 - (y / self.RENDER_SIZE)
                for x in range(self.RENDER_SIZE):
                    sat = x / self.RENDER_SIZE
                    raw_c = QColor.fromHsvF(self.h / 360.0, sat, val)
                    self.cached_square.setPixelColor(x, y, self.quantize_color(raw_c))
        painter.drawImage(square_rect, self.cached_square.scaled(square_rect.size(), Qt.IgnoreAspectRatio, Qt.FastTransformation))

        painter.setRenderHint(QPainter.Antialiasing)
        cx = int(square_rect.left() + (self.s * square_rect.width()))
        cy = int(square_rect.top() + ((1 - self.v) * square_rect.height()))
        cx = max(square_rect.left(), min(square_rect.right(), cx))
        cy = max(square_rect.top(), min(square_rect.bottom(), cy))
        painter.setPen(QPen(Qt.black, 3))
        painter.drawEllipse(QPoint(cx, cy), 6, 6)
        painter.setPen(QPen(Qt.white, 1))
        painter.drawEllipse(QPoint(cx, cy), 6, 6)

        hx = int(hue_rect.left() + (self.h / 360.0 * hue_rect.width()))
        hx = max(hue_rect.left(), min(hue_rect.right(), hx))
        painter.setPen(QPen(Qt.black, 3))
        painter.drawLine(hx, hue_rect.top()-2, hx, hue_rect.bottom()+2)
        painter.setPen(QPen(Qt.white, 1))
        painter.drawLine(hx, hue_rect.top()-2, hx, hue_rect.bottom()+2)

    def mousePressEvent(self, event):
        pos = event.position().toPoint()
        square_rect = self.rect().adjusted(5, 5, -5, -35)
        hue_rect = self.rect().adjusted(5, square_rect.height() + 10, -5, -5)
        if square_rect.contains(pos):
            self.dragging_sv = True
            self.update_sv(pos, square_rect)
        elif hue_rect.contains(pos):
            self.dragging_h = True
            self.update_h(pos, hue_rect)
    def mouseMoveEvent(self, event):
        pos = event.position().toPoint()
        square_rect = self.rect().adjusted(5, 5, -5, -35)
        hue_rect = self.rect().adjusted(5, square_rect.height() + 10, -5, -5)
        if self.dragging_sv: self.update_sv(pos, square_rect)
        elif self.dragging_h: self.update_h(pos, hue_rect)
    def mouseReleaseEvent(self, event):
        self.dragging_sv = False
        self.dragging_h = False
    def update_h(self, pos, rect):
        x = max(0, min(rect.width(), pos.x() - rect.left()))
        self.h = (x / rect.width()) * 360.0
        self.emit_color()
        self.update()
    def update_sv(self, pos, rect):
        x = max(0, min(rect.width(), pos.x() - rect.left()))
        y = max(0, min(rect.height(), pos.y() - rect.top()))
        self.s = x / rect.width()
        self.v = 1.0 - (y / rect.height())
        self.emit_color()
        self.update()
    def emit_color(self):
        c = QColor.fromHsvF(self.h / 360.0, self.s, self.v)
        r5 = int((c.red() / 255.0) * 31)
        g5 = int((c.green() / 255.0) * 31)
        b5 = int((c.blue() / 255.0) * 31)
        if (r5 != self.r5 or g5 != self.g5 or b5 != self.b5):
            self.r5, self.g5, self.b5 = r5, g5, b5
            self.colorChanged.emit(r5, g5, b5)

# === 2. Curve Editor Widget ===
class CurveEditor(QWidget):
    curveChanged = Signal(float, float, float, float)

    def __init__(self):
        super().__init__()
        self.setFixedSize(160, 160)
        self.setStyleSheet("background-color: #333; border: 1px solid #555;")
        self.p1 = QPointF(0.25, 0.25)
        self.p2 = QPointF(0.75, 0.75)
        self.dragging = None # 1 or 2
        self.hover = None

    def set_curve(self, p1x, p1y, p2x, p2y):
        self.p1 = QPointF(p1x, p1y)
        self.p2 = QPointF(p2x, p2y)
        self.update()

    def transform_to_widget(self, pf):
        rect = self.rect().adjusted(15, 15, -15, -15)
        x = rect.left() + pf.x() * rect.width()
        y = rect.bottom() - pf.y() * rect.height() 
        return QPointF(x, y)

    def transform_from_widget(self, point):
        rect = self.rect().adjusted(15, 15, -15, -15)
        x = (point.x() - rect.left()) / rect.width()
        y = (rect.bottom() - point.y()) / rect.height()
        return QPointF(max(0, min(1, x)), max(0, min(1, y)))

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        
        rect = self.rect().adjusted(15, 15, -15, -15)
        painter.setPen(QPen(QColor(80,80,80), 1))
        painter.drawRect(rect)
        painter.drawLine(rect.left(), rect.bottom(), rect.right(), rect.top())

        start = QPointF(rect.left(), rect.bottom())
        end = QPointF(rect.right(), rect.top())
        cp1 = self.transform_to_widget(self.p1)
        cp2 = self.transform_to_widget(self.p2)

        painter.setPen(QPen(QColor(150, 150, 150), 1, Qt.DashLine))
        painter.drawLine(start, cp1)
        painter.drawLine(end, cp2)

        path = QPainterPath()
        path.moveTo(start)
        path.cubicTo(cp1, cp2, end)
        painter.setPen(QPen(Qt.white, 2))
        painter.setBrush(Qt.NoBrush)
        painter.drawPath(path)

        def draw_handle(pt, col):
            painter.setBrush(col)
            painter.setPen(Qt.NoPen)
            painter.drawEllipse(pt, 6, 6)
            painter.setBrush(Qt.NoBrush)
            painter.setPen(Qt.white)
            painter.drawEllipse(pt, 6, 6)

        draw_handle(cp1, QColor("#ff55aadd"))
        draw_handle(cp2, QColor("#55aaffdd"))

    def mousePressEvent(self, event):
        pos = QPointF(event.position())
        cp1 = self.transform_to_widget(self.p1)
        cp2 = self.transform_to_widget(self.p2)
        
        if (pos - cp1).manhattanLength() < 10:
            self.dragging = 1
        elif (pos - cp2).manhattanLength() < 10:
            self.dragging = 2

    def mouseMoveEvent(self, event):
        if self.dragging:
            norm_pos = self.transform_from_widget(QPointF(event.position()))
            if self.dragging == 1:
                self.p1 = norm_pos
            else:
                self.p2 = norm_pos
            self.update()
            self.curveChanged.emit(self.p1.x(), self.p1.y(), self.p2.x(), self.p2.y())

    def mouseReleaseEvent(self, event):
        self.dragging = None

# === 3. Preview Widget ===
class GradientPreviewWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.image = None
        self.zoom_factor = 0 # 0 = Fit, 1 = 1x, etc.
        self.current_w = 256
        self.current_h = 224
        self.setMinimumSize(1, 1)
        self.setStyleSheet("background-color: #111;")
        self.setSizePolicy(
            sys.modules['PySide6.QtWidgets'].QSizePolicy.Ignored, 
            sys.modules['PySide6.QtWidgets'].QSizePolicy.Ignored
        )

    def set_image(self, image):
        self.image = image
        self.current_w = image.width()
        self.current_h = image.height()
        # Refresh the geometry based on the new image size if we are in fixed zoom mode
        if self.zoom_factor > 0:
            self.setFixedSize(self.current_w * self.zoom_factor, self.current_h * self.zoom_factor)
        self.update()

    def set_zoom(self, factor):
        self.zoom_factor = factor
        if factor > 0:
            # Use the current image dimensions for the multiplier
            self.setFixedSize(self.current_w * factor, self.current_h * factor)
        else:
            self.setMaximumSize(16777215, 16777215)
            self.setMinimumSize(1, 1)
        self.updateGeometry()
        self.update()

    def paintEvent(self, event):
        painter = QPainter(self)
        if not self.image:
            painter.setPen(Qt.white)
            painter.drawText(self.rect(), Qt.AlignCenter, "No Preview")
            return

        # "Fit to Window" Mode
        if self.zoom_factor == 0:
            scaled = self.image.scaled(self.size(), Qt.KeepAspectRatio, Qt.FastTransformation)
            x = (self.width() - scaled.width()) // 2
            y = (self.height() - scaled.height()) // 2
            painter.drawImage(x, y, scaled)
        
        # "Fixed Zoom" Mode
        else:
            painter.drawImage(self.rect(), self.image)

# === 4. Sidebar Settings Widget ===
class RenderSettingsWidget(QWidget):
    settingsChanged = Signal()

    def __init__(self):
        super().__init__()
        self.setFixedWidth(240)
        # UPDATED STYLESHEET:
        # Removed 'QSpinBox, QDoubleSpinBox' from the background/border rule 
        # so they use the native/Fusion style like the RGB inputs.
        self.setStyleSheet("""
            QWidget { background-color: #2b2b2b; color: #ddd; }
            QGroupBox { font-weight: bold; border: 1px solid #444; margin-top: 6px; padding-top: 10px; }
            QGroupBox::title { subcontrol-origin: margin; left: 10px; padding: 0 3px; }
            QComboBox { background-color: #444; border: 1px solid #555; padding: 4px; }
            QSlider::groove:horizontal { border: 1px solid #333; height: 6px; background: #111; margin: 2px 0; border-radius: 3px; }
            QSlider::handle:horizontal { background: #0078d7; border: 1px solid #0078d7; width: 14px; margin: -5px 0; border-radius: 7px; }
            QCheckBox { padding: 5px; }
        """)
        
        layout = QVBoxLayout(self)

        # --- PREVIEW ZOOM SETTINGS ---
        grp_view = QGroupBox("Preview View")
        l_view = QVBoxLayout()
        self.combo_zoom = QComboBox()
        self.combo_zoom.addItems([
            "Fit to Window", 
            "1x", 
            "2x", 
            "3x", 
            "4x"
        ])
        self.combo_zoom.setCurrentIndex(3) # Default 3x
        l_view.addWidget(QLabel("Scale:"))
        l_view.addWidget(self.combo_zoom)
        grp_view.setLayout(l_view)
        layout.addWidget(grp_view)

        # --- OUTPUT SETTINGS (Resolution / Bit Depth) ---
        grp_out = QGroupBox("Output Settings")
        l_out = QVBoxLayout()
        
        # Resolution
        res_layout = QGridLayout()
        res_layout.addWidget(QLabel("W:"), 0, 0)
        self.spin_width = QSpinBox()
        self.spin_width.setRange(1, 512)
        self.spin_width.setValue(SNES_WIDTH)
        self.spin_width.valueChanged.connect(lambda: self.settingsChanged.emit())
        res_layout.addWidget(self.spin_width, 0, 1)
        
        res_layout.addWidget(QLabel("H:"), 0, 2)
        self.spin_height = QSpinBox()
        self.spin_height.setRange(1, 512)
        self.spin_height.setValue(SNES_HEIGHT)
        self.spin_height.valueChanged.connect(lambda: self.settingsChanged.emit())
        res_layout.addWidget(self.spin_height, 0, 3)
        l_out.addLayout(res_layout)
        
        # Bit Depth
        depth_layout = QHBoxLayout()
        depth_layout.addWidget(QLabel("Bit Depth:"))
        self.spin_depth = QSpinBox()
        self.spin_depth.setRange(1, 8)
        self.spin_depth.setValue(5) # Default SNES 5-bit
        self.spin_depth.valueChanged.connect(lambda: self.settingsChanged.emit())
        depth_layout.addWidget(self.spin_depth)
        l_out.addLayout(depth_layout)
        
        grp_out.setLayout(l_out)
        layout.addWidget(grp_out)

        # Color Space
        grp_space = QGroupBox("Color Blending")
        l_space = QVBoxLayout()
        self.combo_space = QComboBox()
        self.combo_space.addItems([
            "Standard RGB", 
            "Linear RGB (Physical)",
            "Oklab (Smooth)", 
            "Oklch (Vibrant)", 
            "IPT (Perceptual)",
            "CMY (Subtractive)",
            "YIQ (NTSC)",
            "YDbDr (SECAM)",
            "HSV (Rainbow)", 
            "HSL (Classic)",
            "CIELAB (Standard)",
            "CIELCH (Polar Lab)",
            "xyY (CIE 1931)",
            "XYZ",
            "CIELUV",
            "HWB"
        ])
        self.combo_space.setCurrentIndex(0)
        self.combo_space.currentIndexChanged.connect(lambda: self.settingsChanged.emit())
        l_space.addWidget(QLabel("Color Space:"))
        l_space.addWidget(self.combo_space)
        grp_space.setLayout(l_space)
        layout.addWidget(grp_space)

        # Interpolation
        grp_ease = QGroupBox("Default Interpolation")
        l_ease = QVBoxLayout()
        self.combo_ease = QComboBox()
        self.combo_ease.addItems(list(EASING_FUNCS.keys()))
        self.combo_ease.setCurrentText("Linear")
        self.combo_ease.currentIndexChanged.connect(lambda: self.settingsChanged.emit())
        l_ease.addWidget(QLabel("Global Easing:"))
        l_ease.addWidget(self.combo_ease)
        grp_ease.setLayout(l_ease)
        layout.addWidget(grp_ease)

        # Dithering
        grp_dither = QGroupBox("Smoothing")
        l_dither = QVBoxLayout()
        self.check_enable_dither = QCheckBox("Enable Dithering")
        self.check_enable_dither.setChecked(False)
        self.check_enable_dither.toggled.connect(self.on_dither_toggle)
        l_dither.addWidget(self.check_enable_dither)
        
        self.container_dither_settings = QWidget()
        self.container_dither_settings.setVisible(False)
        l_dither_inner = QVBoxLayout(self.container_dither_settings)
        l_dither_inner.setContentsMargins(0,0,0,0)
        
        self.combo_dither = QComboBox()
        self.combo_dither.addItems([
            "Bayer 2x2",
            "Bayer 4x4 (Standard)",
            "Bayer 8x8 (Smooth)",
            "Cluster 4x4 (Dot)",
            "Scanline Horizontal",
            "Scanline Vertical",
            "White Noise (Grainy)"
        ])
        self.combo_dither.setCurrentIndex(1)
        self.combo_dither.currentIndexChanged.connect(lambda: self.settingsChanged.emit())
        l_dither_inner.addWidget(QLabel("Dither Pattern:"))
        l_dither_inner.addWidget(self.combo_dither)
        
        self.lbl_strength = QLabel("Strength: 100%")
        l_dither_inner.addWidget(self.lbl_strength)
        self.slider_strength = QSlider(Qt.Horizontal)
        self.slider_strength.setRange(0, 150)
        self.slider_strength.setValue(100)
        self.slider_strength.valueChanged.connect(self.on_strength_change)
        l_dither_inner.addWidget(self.slider_strength)
        
        l_dither.addWidget(self.container_dither_settings)
        grp_dither.setLayout(l_dither)
        layout.addWidget(grp_dither)

        layout.addStretch()

    def on_dither_toggle(self, checked):
        self.container_dither_settings.setVisible(checked)
        self.settingsChanged.emit()

    def on_strength_change(self, val):
        self.lbl_strength.setText(f"Strength: {val}%")
        self.settingsChanged.emit()

# === 5. Data Class ===
class SnesStop:
    def __init__(self, position, r, g, b, locked_pos=False):
        self.position = position 
        self.r = int(r)
        self.g = int(g)
        self.b = int(b)
        self.locked_pos = locked_pos
        self.ease_mode = "Global (Default)"
        self.curve_p1 = (0.25, 0.25)
        self.curve_p2 = (0.75, 0.75)

    def get_qt_color(self):
        return QColor(self.r << 3, self.g << 3, self.b << 3)
    
    def to_dict(self):
        return {
            'position': self.position,
            'r': self.r,
            'g': self.g,
            'b': self.b,
            'locked_pos': self.locked_pos,
            'ease_mode': self.ease_mode,
            'curve_p1': self.curve_p1,
            'curve_p2': self.curve_p2
        }
    
    @classmethod
    def from_dict(cls, data):
        stop = cls(
            position=data['position'],
            r=data['r'],
            g=data['g'],
            b=data['b'],
            locked_pos=data.get('locked_pos', False)
        )
        stop.ease_mode = data.get('ease_mode', "Global (Default)")
        stop.curve_p1 = data.get('curve_p1', (0.25, 0.25))
        stop.curve_p2 = data.get('curve_p2', (0.75, 0.75))
        return stop

# === 6. Main Application ===
class SnesGradientTool(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Purp's PRO-Gradient Tool")
        self.resize(1150, 750)

        # Init Data
        self.stops = [] 
        self.selected_index = 0
        self.generated_image = None
        self.updating_ui = False 
        self.is_dragging_slider = False 
        
        # Setup UI
        self.central_widget = QWidget()
        self.setCentralWidget(self.central_widget)
        self.setup_ui()
        self.setup_menu()
        self.apply_preset_white_to_black()

    def setup_menu(self):
        menubar = self.menuBar()

        # --- File ---
        file_menu = menubar.addMenu("File")
        act_save = QAction("Save PNG...", self)
        act_save.triggered.connect(self.save_image)
        file_menu.addAction(act_save)
        file_menu.addSeparator()
        act_exit = QAction("Exit", self)
        act_exit.triggered.connect(self.close)
        file_menu.addAction(act_exit)

        # --- Presets (TOP LEVEL) ---
        presets_menu = menubar.addMenu("Presets")
        builtin_menu = QMenu("Built-in", self)
        actions = [
            ("Normal White → Black", self.apply_preset_white_to_black),
            ("Sunset (Purple → Orange)", self.apply_preset_sunset),
            ("Forest (Green)", self.apply_preset_forest),
            ("Ocean (Blue)", self.apply_preset_ocean),
            ("Neon Cyber", self.apply_preset_neon),
            ("Heatmap", self.apply_preset_heatmap),
        ]
        for name, fn in actions:
            act = QAction(name, self)
            act.triggered.connect(fn)
            builtin_menu.addAction(act)

        presets_menu.addMenu(builtin_menu)
        presets_menu.addSeparator()
        act_save_preset = QAction("Save Current as Preset...", self)
        act_save_preset.triggered.connect(self.save_preset)
        presets_menu.addAction(act_save_preset)
        act_load_preset = QAction("Load Preset...", self)
        act_load_preset.triggered.connect(self.load_preset)
        presets_menu.addAction(act_load_preset)
    def apply_preset_white_to_black(self):
        self.stops = [
            SnesStop(0.0, 31, 31, 31, locked_pos=True),
            SnesStop(1.0, 0, 0, 0, locked_pos=True)
        ]
        self.refresh_stop_list()
        self.update_preview()
    def apply_preset_sunset(self):
        self.stops = [
            SnesStop(0.0, 10, 2, 18, locked_pos=True),
            SnesStop(0.5, 31, 10, 5),
            SnesStop(1.0, 31, 28, 0, locked_pos=True)
        ]
        self.refresh_stop_list()
        self.update_preview()
    def apply_preset_forest(self):
        self.stops = [
            SnesStop(0.0, 2, 8, 2, locked_pos=True),
            SnesStop(0.5, 10, 25, 5),
            SnesStop(1.0, 28, 31, 15, locked_pos=True)
        ]
        self.refresh_stop_list()
        self.update_preview()
    def apply_preset_ocean(self):
        self.stops = [
            SnesStop(0.0, 0, 2, 12, locked_pos=True),
            SnesStop(0.5, 0, 15, 31),
            SnesStop(1.0, 25, 31, 31, locked_pos=True)
        ]
        self.refresh_stop_list()
        self.update_preview()
    def apply_preset_neon(self):
        self.stops = [
            SnesStop(0.0, 31, 0, 20, locked_pos=True),
            SnesStop(1.0, 0, 31, 31, locked_pos=True)
        ]
        self.refresh_stop_list()
        self.update_preview()
    def apply_preset_heatmap(self):
        self.stops = [
            SnesStop(0.0, 0, 0, 31, locked_pos=True),
            SnesStop(0.5, 0, 31, 0),
            SnesStop(1.0, 31, 0, 0, locked_pos=True)
        ]
        self.refresh_stop_list()
        self.update_preview()
    def save_preset(self):
        if len(self.stops) == 0: return
        file_path, _ = QFileDialog.getSaveFileName(self, "Save Preset", "", "JSON Preset Files (*.json);;All Files (*)")
        if not file_path: return
        if not file_path.lower().endswith('.json'): file_path += '.json'
        
        try:
            preset_data = {
                'stops': [stop.to_dict() for stop in self.stops],
                'settings': {
                    'color_space': self.settings_sidebar.combo_space.currentText(),
                    'global_easing': self.settings_sidebar.combo_ease.currentText(),
                    'dither_enabled': self.settings_sidebar.check_enable_dither.isChecked(),
                    'dither_mode': self.settings_sidebar.combo_dither.currentText(),
                    'dither_strength': self.settings_sidebar.slider_strength.value()
                }
            }
            with open(file_path, 'w', encoding='utf-8') as f:
                json.dump(preset_data, f, indent=2)
            QMessageBox.information(self, "Preset Saved", f"Preset saved to:\n{file_path}")
        except Exception as e:
            QMessageBox.critical(self, "Save Error", f"Failed to save preset:\n{str(e)}")
    def load_preset(self):
        file_path, _ = QFileDialog.getOpenFileName(self, "Load Preset", "", "JSON Preset Files (*.json);;All Files (*)")
        if not file_path: return
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                preset_data = json.load(f)
            self.stops = []
            for stop_data in preset_data['stops']:
                self.stops.append(SnesStop.from_dict(stop_data))
            if 'settings' in preset_data:
                settings = preset_data['settings']
                
                color_space = settings.get('color_space', 'Oklch (Vibrant)')
                idx = self.settings_sidebar.combo_space.findText(color_space)
                if idx >= 0: self.settings_sidebar.combo_space.setCurrentIndex(idx)
                
                global_easing = settings.get('global_easing', 'Linear')
                idx = self.settings_sidebar.combo_ease.findText(global_easing)
                if idx >= 0: self.settings_sidebar.combo_ease.setCurrentIndex(idx)
                
                dither_en = settings.get('dither_enabled', True)
                self.settings_sidebar.check_enable_dither.setChecked(dither_en)

                dither_mode = settings.get('dither_mode', "Bayer 4x4 (Standard)")
                idx = self.settings_sidebar.combo_dither.findText(dither_mode)
                if idx >= 0: self.settings_sidebar.combo_dither.setCurrentIndex(idx)

                self.settings_sidebar.slider_strength.setValue(settings.get('dither_strength', 100))
            
            self.refresh_stop_list()
            self.update_preview()
            
        except Exception as e:
            QMessageBox.critical(self, "Load Error", f"Failed to load preset:\n{str(e)}")

    def setup_ui(self):
        main_layout = QHBoxLayout(self.central_widget)
        main_layout.setContentsMargins(0, 0, 0, 0)
        splitter = QSplitter(Qt.Horizontal)
        main_layout.addWidget(splitter)

        # === LEFT PANEL CONTAINER ===
        # This holds the Scroll Area (Top) and the Fixed Buttons (Bottom)
        left_panel_widget = QWidget()
        left_panel_layout = QVBoxLayout(left_panel_widget)
        left_panel_layout.setContentsMargins(0, 0, 0, 0)
        left_panel_layout.setSpacing(0)

        # --- 1. SCROLLABLE CONTENT (List + Edit Controls) ---
        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setFrameShape(QFrame.NoFrame)
        
        controls_content = QWidget()
        controls_layout = QVBoxLayout(controls_content)
        # Add some padding inside the scroll area so it looks nice
        controls_layout.setContentsMargins(10, 10, 10, 10) 

        # -- Stop List Group --
        grp_stops = QGroupBox("Stops List")
        layout_stops = QVBoxLayout()
        self.list_stops = QListWidget()
        self.list_stops.currentRowChanged.connect(self.on_stop_selected)
        layout_stops.addWidget(self.list_stops)
        
        # Tools Layout
        tools_layout = QGridLayout()
        self.btn_add = QPushButton("Add")
        self.btn_add.clicked.connect(self.add_stop)
        tools_layout.addWidget(self.btn_add, 0, 0)
        self.btn_remove = QPushButton("Remove")
        self.btn_remove.clicked.connect(self.remove_stop)
        tools_layout.addWidget(self.btn_remove, 0, 1)
        self.btn_dup = QPushButton("Duplicate")
        self.btn_dup.clicked.connect(self.duplicate_selected)
        tools_layout.addWidget(self.btn_dup, 0, 2)
        self.btn_rev = QPushButton("Reverse")
        self.btn_rev.clicked.connect(self.reverse_stops)
        tools_layout.addWidget(self.btn_rev, 1, 0)
        self.btn_dist = QPushButton("Distribute")
        self.btn_dist.clicked.connect(self.distribute_stops)
        tools_layout.addWidget(self.btn_dist, 1, 1, 1, 2)

        layout_stops.addLayout(tools_layout)
        grp_stops.setLayout(layout_stops)
        controls_layout.addWidget(grp_stops)

        # -- Edit Group --
        self.grp_edit = QGroupBox("Edit Selected Stop")
        layout_edit = QVBoxLayout()
        
        # Position
        pos_row = QHBoxLayout()
        pos_row.addWidget(QLabel("Pos:"))
        self.slider_pos = QSlider(Qt.Horizontal)
        self.slider_pos.setRange(0, 1000)
        self.slider_pos.valueChanged.connect(self.on_slider_pos_change)
        self.slider_pos.sliderPressed.connect(self.on_slider_pressed)
        self.slider_pos.sliderReleased.connect(self.on_slider_released)
        pos_row.addWidget(self.slider_pos)
        self.spin_pos = QDoubleSpinBox()
        self.spin_pos.setRange(0.0, 1.0)
        self.spin_pos.setSingleStep(0.01)
        self.spin_pos.valueChanged.connect(self.on_spin_pos_change)
        pos_row.addWidget(self.spin_pos)
        layout_edit.addLayout(pos_row)

        # Color
        picker_layout = QHBoxLayout()
        self.color_picker = SnesColorPicker()
        self.color_picker.colorChanged.connect(self.on_picker_change)
        picker_layout.addWidget(self.color_picker)
        rgb_nums_layout = QVBoxLayout()
        self.spin_r = self.create_rgb_spin("R", "#ff5555", rgb_nums_layout)
        self.spin_g = self.create_rgb_spin("G", "#55ff55", rgb_nums_layout)
        self.spin_b = self.create_rgb_spin("B", "#5555ff", rgb_nums_layout)

        hex_layout = QHBoxLayout()
        lbl_hex = QLabel("Hex")
        lbl_hex.setStyleSheet("font-weight: bold; color: #ddd; margin-right: 5px;")
        hex_layout.addWidget(lbl_hex)
        
        self.line_hex = QLineEdit()
        self.line_hex.setPlaceholderText("#000000")
        self.line_hex.setMaxLength(7)
        self.line_hex.editingFinished.connect(self.on_hex_submit)
        hex_layout.addWidget(self.line_hex)
        rgb_nums_layout.addLayout(hex_layout)

        rgb_nums_layout.addStretch()
        picker_layout.addLayout(rgb_nums_layout)
        layout_edit.addLayout(picker_layout)

        # Segment Easing Control
        self.grp_ease_step = QGroupBox("Transition to Next Stop")
        l_ease_step = QVBoxLayout()
        
        self.combo_step_ease = QComboBox()
        self.combo_step_ease.addItems(["Global (Default)", "Custom Curve"] + list(EASING_FUNCS.keys()))
        self.combo_step_ease.currentIndexChanged.connect(self.on_step_ease_changed)
        l_ease_step.addWidget(self.combo_step_ease)
        
        self.container_curve = QWidget()
        l_curve = QVBoxLayout(self.container_curve)
        l_curve.setContentsMargins(0,0,0,0)
        self.curve_editor = CurveEditor()
        self.curve_editor.curveChanged.connect(self.on_curve_changed)
        l_curve.addWidget(self.curve_editor)
        l_ease_step.addWidget(self.container_curve)
        
        self.grp_ease_step.setLayout(l_ease_step)
        layout_edit.addWidget(self.grp_ease_step)

        self.grp_edit.setLayout(layout_edit)
        controls_layout.addWidget(self.grp_edit)
        
        # Add a stretch here so the controls stick to the top of the scroll area
        controls_layout.addStretch()

        # Finalize Scroll Area
        scroll_area.setWidget(controls_content)
        left_panel_layout.addWidget(scroll_area)

        # --- 2. FIXED BOTTOM CONTENT (Buttons) ---
        bottom_controls = QWidget()
        # Removed the setStyleSheet line here to keep original look
        
        bottom_layout = QVBoxLayout(bottom_controls)
        bottom_layout.setContentsMargins(10, 10, 10, 10)

        self.btn_save = QPushButton("Save PNG")
        self.btn_save.setFixedHeight(40)
        self.btn_save.setStyleSheet("background-color: #0078d7; color: white; font-weight: bold;")
        self.btn_save.clicked.connect(self.save_image)
        bottom_layout.addWidget(self.btn_save)

        # Add preset buttons
        preset_buttons = QHBoxLayout()
        self.btn_save_preset = QPushButton("Save Preset")
        self.btn_save_preset.clicked.connect(self.save_preset)
        preset_buttons.addWidget(self.btn_save_preset)
        
        self.btn_load_preset = QPushButton("Load Preset")
        self.btn_load_preset.clicked.connect(self.load_preset)
        preset_buttons.addWidget(self.btn_load_preset)
        bottom_layout.addLayout(preset_buttons)

        # Add the bottom controls to the main left layout
        left_panel_layout.addWidget(bottom_controls)

        # Set minimum width for the whole left panel
        left_panel_widget.setMinimumWidth(340)

        # --- ASSEMBLE SPLITTER ---
        splitter.addWidget(left_panel_widget)

        # PREVIEW
        preview_container = QWidget()
        preview_layout = QVBoxLayout(preview_container)
        preview_layout.setContentsMargins(0,0,0,0)
        
        # Wrap Preview in a Scroll Area for handling 2x/3x/4x sizes
        self.preview_scroll = QScrollArea()
        self.preview_scroll.setStyleSheet("background-color: #111; border: 1px solid #444;")
        self.preview_scroll.setAlignment(Qt.AlignCenter) # Keep image centered
        
        self.preview_widget = GradientPreviewWidget()
        self.preview_scroll.setWidget(self.preview_widget)
        
        # Default to Resizable (Fit Mode)
        self.preview_scroll.setWidgetResizable(True)
        
        preview_layout.addWidget(self.preview_scroll)
        splitter.addWidget(preview_container)

        # SETTINGS
        self.settings_sidebar = RenderSettingsWidget()
        self.settings_sidebar.settingsChanged.connect(self.update_preview)
        # Connect Zoom Combo (Assuming you added this from the previous step)
        self.settings_sidebar.combo_zoom.currentIndexChanged.connect(self.on_zoom_changed)
        splitter.addWidget(self.settings_sidebar)

        splitter.setStretchFactor(0, 0)
        splitter.setStretchFactor(1, 1)
        splitter.setStretchFactor(2, 0)
        self.on_zoom_changed(3)

    def create_rgb_spin(self, label, color, parent_layout):
        layout = QHBoxLayout()
        lbl = QLabel(label)
        lbl.setStyleSheet(f"font-weight: bold; color: {color}")
        layout.addWidget(lbl)
        spin = QSpinBox()
        spin.setRange(0, 31)
        spin.valueChanged.connect(self.on_spin_rgb_change)
        layout.addWidget(spin)
        parent_layout.addLayout(layout)
        return spin
    def refresh_stop_list(self):
        self.updating_ui = True
        current_selection = self.stops[self.selected_index] if 0 <= self.selected_index < len(self.stops) else None
        self.stops.sort(key=lambda x: x.position)
        
        self.list_stops.clear()
        for i, stop in enumerate(self.stops):
            label = f"#{i+1} Pos:{stop.position:.2f}"
            if stop.locked_pos: label += " (L)"
            item = QListWidgetItem(label)
            pix = QPixmap(16, 16)
            pix.fill(stop.get_qt_color())
            item.setIcon(QIcon(pix))
            self.list_stops.addItem(item)
            
        if current_selection:
            try:
                idx = self.stops.index(current_selection)
                self.list_stops.setCurrentRow(idx)
                self.selected_index = idx
            except ValueError:
                self.list_stops.setCurrentRow(0)
                self.selected_index = 0
        else:
            self.list_stops.setCurrentRow(0)
            self.selected_index = 0
        self.updating_ui = False
    def on_stop_selected(self, index):
        if index < 0 or index >= len(self.stops): return
        if self.is_dragging_slider: return

        self.selected_index = index
        self.grp_edit.setEnabled(True)
        stop = self.stops[index]

        self.updating_ui = True
        self.slider_pos.setEnabled(not stop.locked_pos)
        self.spin_pos.setEnabled(not stop.locked_pos)
        self.btn_remove.setEnabled(not stop.locked_pos)
        self.slider_pos.setValue(int(stop.position * 1000))
        self.spin_pos.setValue(stop.position)
        self.spin_r.setValue(stop.r)
        self.spin_g.setValue(stop.g)
        self.spin_b.setValue(stop.b)
        self.color_picker.set_color_5bit(stop.r, stop.g, stop.b)

        self.update_hex_display(stop.r, stop.g, stop.b)

        if index == len(self.stops) - 1:
            self.grp_ease_step.setVisible(False)
        else:
            self.grp_ease_step.setVisible(True)
            self.combo_step_ease.setCurrentText(stop.ease_mode)
            self.container_curve.setVisible(stop.ease_mode == "Custom Curve")
            self.curve_editor.set_curve(stop.curve_p1[0], stop.curve_p1[1], stop.curve_p2[0], stop.curve_p2[1])

        self.updating_ui = False
    def on_step_ease_changed(self, idx):
        if self.updating_ui: return
        stop = self.stops[self.selected_index]
        txt = self.combo_step_ease.currentText()
        stop.ease_mode = txt
        self.container_curve.setVisible(txt == "Custom Curve")
        self.update_preview()
    def on_curve_changed(self, p1x, p1y, p2x, p2y):
        if self.updating_ui: return
        stop = self.stops[self.selected_index]
        stop.curve_p1 = (p1x, p1y)
        stop.curve_p2 = (p2x, p2y)
        self.update_preview()
    def on_slider_pressed(self): self.is_dragging_slider = True
    def on_slider_released(self):
        self.is_dragging_slider = False
        self.refresh_stop_list()
    def on_slider_pos_change(self, value):
        if self.updating_ui: return
        self.spin_pos.blockSignals(True)
        self.spin_pos.setValue(value / 1000.0)
        self.spin_pos.blockSignals(False)
        self.update_stop_data(pos_changed=True)
    def on_spin_pos_change(self, value):
        if self.updating_ui: return
        self.slider_pos.blockSignals(True)
        self.slider_pos.setValue(int(value * 1000))
        self.slider_pos.blockSignals(False)
        self.update_stop_data(pos_changed=True)
    def on_picker_change(self, r, g, b):
        if self.updating_ui: return
        self.updating_ui = True
        self.spin_r.setValue(r)
        self.spin_g.setValue(g)
        self.spin_b.setValue(b)
        self.updating_ui = False
        self.update_stop_data()
    def on_spin_rgb_change(self):
        if self.updating_ui: return
        r, g, b = self.spin_r.value(), self.spin_g.value(), self.spin_b.value()
        self.updating_ui = True
        self.color_picker.set_color_5bit(r, g, b)
        self.updating_ui = False
        self.update_stop_data()
    def update_stop_data(self, pos_changed=False):
        stop = self.stops[self.selected_index]
        stop.r = self.spin_r.value()
        stop.g = self.spin_g.value()
        stop.b = self.spin_b.value()

        self.update_hex_display(stop.r, stop.g, stop.b)

        if pos_changed and not stop.locked_pos:
            stop.position = self.slider_pos.value() / 1000.0
        self.update_preview()
        if not self.is_dragging_slider:
             item = self.list_stops.item(self.list_stops.currentRow())
             if item:
                pix = QPixmap(16, 16)
                pix.fill(stop.get_qt_color())
                item.setIcon(QIcon(pix))
    def add_stop(self):
        new_stop = SnesStop(0.5, 15, 15, 15)
        self.stops.append(new_stop)
        self.refresh_stop_list()
        self.update_preview()      
    def duplicate_selected(self):
        if self.selected_index < 0 or self.selected_index >= len(self.stops): return
        orig = self.stops[self.selected_index]
        new_pos = min(1.0, orig.position + 0.05)
        new_stop = SnesStop(new_pos, orig.r, orig.g, orig.b, locked_pos=False)
        new_stop.ease_mode = orig.ease_mode
        new_stop.curve_p1 = orig.curve_p1
        new_stop.curve_p2 = orig.curve_p2
        self.stops.append(new_stop)
        self.refresh_stop_list()
        self.update_preview()
    def remove_stop(self):
        if self.stops[self.selected_index].locked_pos: return
        self.stops.pop(self.selected_index)
        self.selected_index = max(0, self.selected_index - 1)
        self.refresh_stop_list()
        self.update_preview()      
    def distribute_stops(self):
        if len(self.stops) < 2: return
        self.stops.sort(key=lambda x: x.position)
        count = len(self.stops)
        for i in range(count):
            self.stops[i].position = i / (count - 1)
        self.refresh_stop_list()
        self.update_preview()
    def reverse_stops(self):
        for s in self.stops:
            s.position = 1.0 - s.position
        self.stops.sort(key=lambda x: x.position)
        self.refresh_stop_list()
        self.update_preview()

    # === RENDER LOGIC ===
    def update_preview(self):
        if len(self.stops) < 2: return
        
        # 1. Get Output Settings
        out_w = self.settings_sidebar.spin_width.value()
        out_h = self.settings_sidebar.spin_height.value()
        bit_depth = self.settings_sidebar.spin_depth.value()
        
        # 2. Math for bit depth
        # Max integer value (e.g., 5-bit = 31)
        max_val = (1 << bit_depth) - 1
        # Bucket count (e.g., 5-bit = 32). This is the scaler for 0.0-1.0 range.
        # We use float buckets to ensure the top value has width.
        buckets = float(1 << bit_depth) 
        
        image = QImage(out_w, out_h, QImage.Format_RGB32)
        
        mode = self.settings_sidebar.combo_space.currentText()
        global_ease_name = self.settings_sidebar.combo_ease.currentText()
        
        dither_enabled = self.settings_sidebar.check_enable_dither.isChecked()
        dither_mode = self.settings_sidebar.combo_dither.currentText()
        dither_strength = self.settings_sidebar.slider_strength.value() / 100.0
        
        sorted_stops = sorted(self.stops, key=lambda x: x.position)
        
        stops_high = []
        is_polar = any(x in mode for x in ["HSV", "HSL", "Oklch", "CIELCH", "HWB"])

        # Pre-convert stops to selected color space
        # Note: Stops are stored as 0-31 integers (5-bit). We normalize to 0.0-1.0
        for s in sorted_stops:
            fr, fg, fb = s.r/31.0, s.g/31.0, s.b/31.0
            
            # --- CONVERSION DISPATCH ---
            if "Oklab" in mode: c1, c2, c3 = rgb_to_oklab(fr, fg, fb)
            elif "Oklch" in mode: c1, c2, c3 = rgb_to_oklch(fr, fg, fb)
            elif "Linear RGB" in mode: c1, c2, c3 = srgb_to_linear(fr), srgb_to_linear(fg), srgb_to_linear(fb)
            elif "HSV" in mode:
                c = QColor.fromRgbF(fr, fg, fb)
                c1, c2, c3 = c.hueF(), c.saturationF(), c.valueF()
            elif "HSL" in mode:
                c = QColor.fromHslF(fr, fg, fb)
                h, s_hsl, l_hsl, _ = c.getHslF()
                c1, c2, c3 = h, s_hsl, l_hsl
            elif "CIELAB" in mode: c1, c2, c3 = rgb_to_cielab(fr, fg, fb)
            elif "CIELCH(uv)" in mode: c1, c2, c3 = rgb_to_cielchuv(fr, fg, fb)
            elif "CIELCH" in mode: c1, c2, c3 = rgb_to_cielch(fr, fg, fb)
            elif "xyY" in mode: c1, c2, c3 = rgb_to_xyy(fr, fg, fb)
            elif "XYZ" in mode: c1, c2, c3 = rgb_to_xyz(fr, fg, fb)
            elif "CIELUV" in mode: c1, c2, c3 = rgb_to_cieluv(fr, fg, fb)
            elif "YCbCr" in mode: c1, c2, c3 = rgb_to_ycbcr(fr, fg, fb)
            elif "YPbPr" in mode: c1, c2, c3 = rgb_to_ypbpr(fr, fg, fb)
            elif "HWB" in mode: c1, c2, c3 = rgb_to_hwb(fr, fg, fb)
            elif "IPT" in mode: c1, c2, c3 = rgb_to_ipt(fr, fg, fb)
            elif "CMY" in mode: c1, c2, c3 = rgb_to_cmy(fr, fg, fb)
            elif "YIQ" in mode: c1, c2, c3 = rgb_to_yiq(fr, fg, fb)
            elif "YDbDr" in mode: c1, c2, c3 = rgb_to_ydbdr(fr, fg, fb)
            else: c1, c2, c3 = fr, fg, fb # Standard RGB
            
            if is_polar and c1 < 0: c1 = 0.0
            stops_high.append({'pos': s.position, 'c': (c1, c2, c3), 'obj': s})

        # Pre-calculate dither matrix data
        dither_matrix = []
        dither_size = 0
        is_matrix_dither = False
        is_noise_dither = False
        is_scanline = False
        
        if dither_enabled:
            if "Bayer" in dither_mode:
                is_matrix_dither = True
                key = dither_mode.split(" (")[0]
                dither_data = DITHER_MATRICES.get(key, DITHER_MATRICES["Bayer 4x4"])
                dither_matrix = dither_data["data"]
                dither_size = dither_data["size"]
            elif "Cluster" in dither_mode:
                is_matrix_dither = True
                dither_data = DITHER_MATRICES["Cluster 4x4"]
                dither_matrix = dither_data["data"]
                dither_size = dither_data["size"]
            elif "Scanline" in dither_mode:
                is_scanline = True
            elif "Noise" in dither_mode:
                is_noise_dither = True
        
        # Rendering Loop
        for y in range(out_h):
            global_t = y / (out_h - 1) if out_h > 1 else 0.0
            s1 = stops_high[0]
            s2 = stops_high[-1]
            
            # Find current segment
            for i in range(len(stops_high) - 1):
                if stops_high[i]['pos'] <= global_t <= stops_high[i+1]['pos']:
                    s1 = stops_high[i]
                    s2 = stops_high[i+1]
                    break
            
            dist = s2['pos'] - s1['pos']
            t_linear = 0.0 if dist <= 0 else (global_t - s1['pos']) / dist
            
            # Ease
            ease_mode = s1['obj'].ease_mode
            if ease_mode == "Global (Default)":
                t = EASING_FUNCS.get(global_ease_name, ease_linear)(t_linear)
            elif ease_mode == "Custom Curve":
                t = eval_custom_curve(t_linear, s1['obj'].curve_p1, s1['obj'].curve_p2)
            else:
                t = EASING_FUNCS.get(ease_mode, ease_linear)(t_linear)

            # Interpolate
            v1 = s1['c']
            v2 = s2['c']
            res = [0.0, 0.0, 0.0]
            
            hue_idx = -1
            scale = 1.0
            if "Oklch" in mode or "CIELCH" in mode: hue_idx = 2; scale = 360.0
            elif "HSV" in mode or "HSL" in mode or "HWB" in mode: hue_idx = 0; scale = 1.0
            
            for k in range(3):
                val1 = v1[k]
                val2 = v2[k]
                if k == hue_idx: 
                    if abs(val1 - val2) > scale / 2:
                        if val1 < val2: val1 += scale
                        else: val2 += scale
                    val = val1 + (val2 - val1) * t
                    if val > scale: val -= scale
                    if val < 0: val += scale
                    res[k] = val
                else:
                    res[k] = val1 + (val2 - val1) * t

            # Back to sRGB
            if "Oklab" in mode: r_f, g_f, b_f = oklab_to_rgb(*res)
            elif "Oklch" in mode: r_f, g_f, b_f = oklch_to_rgb(*res)
            elif "Linear RGB" in mode: r_f, g_f, b_f = linear_to_srgb(res[0]), linear_to_srgb(res[1]), linear_to_srgb(res[2])
            elif "HSV" in mode:
                c = QColor.fromHsvF(max(0,min(1,res[0])), max(0,min(1,res[1])), max(0,min(1,res[2])))
                r_f, g_f, b_f = c.redF(), c.greenF(), c.blueF()
            elif "HSL" in mode:
                c = QColor.fromHslF(max(0,min(1,res[0])), max(0,min(1,res[1])), max(0,min(1,res[2])))
                r_f, g_f, b_f = c.redF(), c.greenF(), c.blueF()
            elif "CIELAB" in mode: r_f, g_f, b_f = cielab_to_rgb(*res)
            elif "CIELCH(uv)" in mode: r_f, g_f, b_f = cielchuv_to_rgb(*res)
            elif "CIELCH" in mode: r_f, g_f, b_f = cielch_to_rgb(*res)
            elif "xyY" in mode: r_f, g_f, b_f = xyy_to_rgb(*res)
            elif "XYZ" in mode: r_f, g_f, b_f = xyz_to_rgb(*res)
            elif "CIELUV" in mode: r_f, g_f, b_f = cieluv_to_rgb(*res)
            elif "YCbCr" in mode: r_f, g_f, b_f = ycbcr_to_rgb(*res)
            elif "YPbPr" in mode: r_f, g_f, b_f = ypbpr_to_rgb(*res)
            elif "HWB" in mode: r_f, g_f, b_f = hwb_to_rgb(*res)
            elif "IPT" in mode: r_f, g_f, b_f = ipt_to_rgb(*res)
            elif "CMY" in mode: r_f, g_f, b_f = cmy_to_rgb(*res)
            elif "YIQ" in mode: r_f, g_f, b_f = yiq_to_rgb(*res)
            elif "YDbDr" in mode: r_f, g_f, b_f = ydbdr_to_rgb(*res)
            else: r_f, g_f, b_f = res

            # Scale to variable Bit Depth
            # Use buckets (max_val + 1) to allow top bucket to exist
            r_scaled = max(0.0, min(1.0, r_f)) * buckets
            g_scaled = max(0.0, min(1.0, g_f)) * buckets
            b_scaled = max(0.0, min(1.0, b_f)) * buckets
            
            # Helper to convert variable-bit int back to 8-bit (0-255) for display
            # We must handle max_val=1 (1-bit) carefully to avoid div by zero if logic failed, 
            # though max_val >= 1 for depth >= 1.
            def to_8bit(val_int):
                if max_val == 0: return 0
                return int((val_int * 255) / max_val)

            # === FAST PATH OPTIMIZATION (CLEAN) ===
            if not dither_enabled:
                r_int = int(clamp(r_scaled, 0, max_val))
                g_int = int(clamp(g_scaled, 0, max_val))
                b_int = int(clamp(b_scaled, 0, max_val))
                
                rgb_val = (0xFF << 24) | (to_8bit(r_int) << 16) | (to_8bit(g_int) << 8) | to_8bit(b_int)
                for x in range(out_w):
                    image.setPixel(x, y, rgb_val)
                    
            # === MATRIX/SCANLINE OPTIMIZATION (DITHER) ===
            elif is_matrix_dither or is_scanline:
                row_pattern = []
                loop_w = dither_size if is_matrix_dither else 2
                
                for x_mod in range(loop_w):
                    noise = 0.0
                    if is_matrix_dither:
                        mat_val = dither_matrix[(y % dither_size) * dither_size + x_mod]
                        max_mat = (dither_size * dither_size)
                        noise = ((mat_val / max_mat) - 0.5) * dither_strength
                    elif is_scanline:
                        if "Horizontal" in dither_mode:
                            noise = (0.5 if (y % 2) == 0 else -0.5) * dither_strength * 0.5
                        else: # Vertical
                            noise = (0.5 if (x_mod % 2) == 0 else -0.5) * dither_strength * 0.5
                    
                    r_d = int(clamp(r_scaled + noise, 0, max_val))
                    g_d = int(clamp(g_scaled + noise, 0, max_val))
                    b_d = int(clamp(b_scaled + noise, 0, max_val))
                    
                    rgb_val = (0xFF << 24) | (to_8bit(r_d) << 16) | (to_8bit(g_d) << 8) | to_8bit(b_d)
                    row_pattern.append(rgb_val)
                
                for x in range(out_w):
                    image.setPixel(x, y, row_pattern[x % loop_w])

            # === SLOW PATH (NOISE) ===
            else:
                for x in range(out_w):
                    noise = random.uniform(-0.5, 0.5) * dither_strength
                    r_d = int(clamp(r_scaled + noise, 0, max_val))
                    g_d = int(clamp(g_scaled + noise, 0, max_val))
                    b_d = int(clamp(b_scaled + noise, 0, max_val))
                    
                    val = (0xFF << 24) | (to_8bit(r_d) << 16) | (to_8bit(g_d) << 8) | to_8bit(b_d)
                    image.setPixel(x, y, val)

        self.generated_image = image
        self.preview_widget.set_image(image)  

    def save_image(self):
        if not self.generated_image: return
        file_path, _ = QFileDialog.getSaveFileName(self, "Save Image", "", "PNG Files (*.png)")
        if file_path:
            self.generated_image.save(file_path)
            QMessageBox.information(self, "Success", f"Saved to {file_path}")
    def update_hex_display(self, r5, g5, b5):
        r8 = (r5 * 255) // 31
        g8 = (g5 * 255) // 31
        b8 = (b5 * 255) // 31
        self.line_hex.setText(f"#{r8:02X}{g8:02X}{b8:02X}")
    def on_hex_submit(self):
        text = self.line_hex.text().lstrip('#')
        if len(text) not in (3, 6):
            stop = self.stops[self.selected_index]
            self.update_hex_display(stop.r, stop.g, stop.b)
            return
        try:
            if len(text) == 3: text = "".join(c*2 for c in text)
            val = int(text, 16)
            r8 = (val >> 16) & 0xFF
            g8 = (val >> 8) & 0xFF
            b8 = val & 0xFF
            self.spin_r.setValue(int(round(r8 * 31 / 255)))
            self.spin_g.setValue(int(round(g8 * 31 / 255)))
            self.spin_b.setValue(int(round(b8 * 31 / 255)))
        except ValueError:
            pass
        
    def on_zoom_changed(self, index):
            # Index 0 is "Fit", 1 is "1x", 2 is "2x", etc.
            if index == 0:
                self.preview_scroll.setWidgetResizable(True) # Allow widget to shrink/grow with window
                self.preview_widget.set_zoom(0)
            else:
                self.preview_scroll.setWidgetResizable(False) # Widget dictates size
                self.preview_widget.set_zoom(index) # 1, 2, 3, 4

  


if __name__ == "__main__":
    app = QApplication(sys.argv)
    app.setStyle("Fusion")
    window = SnesGradientTool()
    window.show()
    sys.exit(app.exec())