MoneyPackCleaner ELITE v3 - Maximum animations, alive UI, particles, glow, waves

moneypack_elite.py

@@ -0,0 +1,1196 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+MoneyPackCleaner ELITE v3.0
+The most animated, alive, eye-catching cleaner UI ever built.
+Every element breathes, pulses, glows, and pops.
+Created by MoneyPack
+"""
+
+APP_VERSION = "3.0.0"
+
+import os, sys, time, math, shutil, hashlib, platform, json, random, subprocess, urllib.request
+from pathlib import Path
+from datetime import datetime
+from collections import defaultdict
+from typing import List
+
+from PyQt6.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QLabel, QPushButton, QStackedWidget, QTreeWidget, QTreeWidgetItem,
+    QTableWidget, QTableWidgetItem, QHeaderView, QAbstractItemView,
+    QTextEdit, QLineEdit, QFileDialog, QMessageBox, QFrame,
+    QSpinBox, QSystemTrayIcon, QMenu, QCheckBox, QGraphicsDropShadowEffect,
+    QProgressBar, QGroupBox
+)
+from PyQt6.QtCore import (
+    Qt, QThread, pyqtSignal, QTimer, QSize, QPropertyAnimation,
+    QPoint, QRect, QEasingCurve, QPointF, pyqtProperty, QRectF,
+    QParallelAnimationGroup, QSequentialAnimationGroup
+)
+from PyQt6.QtGui import (
+    QFont, QColor, QAction, QIcon, QPainter, QPen, QBrush,
+    QLinearGradient, QRadialGradient, QPixmap, QPainterPath,
+    QConicalGradient, QMouseEvent, QFontMetrics
+)
+
+
+# ═══════════════════════════════════════════════════════════════
+# PALETTE
+# ═══════════════════════════════════════════════════════════════
+
+class C:
+    BG = "#06060e"
+    BG2 = "#0c0c18"
+    PANEL = "#101025"
+    CARD = "#161635"
+    HOVER = "#1e1e45"
+    GOLD = "#d4af37"
+    GOLD2 = "#ffd700"
+    PINK = "#ff1a5c"
+    PINK2 = "#ff4d88"
+    CYAN = "#00e5ff"
+    CYAN2 = "#00ffff"
+    PURPLE = "#a855f7"
+    BLUE = "#3b82f6"
+    WHITE = "#f8f8ff"
+    TEXT = "#c4c4e0"
+    DIM = "#5c5c80"
+    MUTED = "#2e2e50"
+    GREEN = "#00e676"
+    YELLOW = "#ffc107"
+    RED = "#ff1744"
+    GLASS = "#ffffff06"
+    BORDER = "#ffffff10"
+
+
+def format_size(b):
+    if b <= 0: return "0 B"
+    for u in ['B','KB','MB','GB','TB']:
+        if b < 1024: return f"{b:.1f} {u}"
+        b /= 1024
+    return f"{b:.1f} PB"
+
+
+# ═══════════════════════════════════════════════════════════════
+# ENGINE (condensed)
+# ═══════════════════════════════════════════════════════════════
+
+class E:
+    SKIP = {'$Recycle.Bin','System Volume Information','Windows','WinSxS','node_modules','.git','__pycache__','venv','.venv','Recovery','proc','sys','dev'}
+    CATS = {'Video':{'.mp4','.avi','.mkv','.mov','.wmv','.webm'},'Audio':{'.mp3','.wav','.flac','.aac','.ogg'},'Image':{'.jpg','.jpeg','.png','.gif','.bmp','.webp','.psd'},'Archive':{'.zip','.rar','.7z','.tar','.gz','.iso'},'Document':{'.pdf','.doc','.docx','.xls','.xlsx','.ppt','.pptx','.txt'},'Installer':{'.exe','.msi','.dmg','.deb'}}
+    
+    @classmethod
+    def cat(cls, ext):
+        for c, es in cls.CATS.items():
+            if ext.lower() in es: return c
+        return "Other"
+    
+    @classmethod
+    def disks(cls):
+        ds = []
+        if sys.platform == 'win32':
+            try:
+                import ctypes
+                bm = ctypes.windll.kernel32.GetLogicalDrives()
+                for l in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
+                    if bm & 1:
+                        try:
+                            u = shutil.disk_usage(f"{l}:\\")
+                            if u.total > 0: ds.append({'d':f"{l}:",'t':u.total,'u':u.used,'f':u.free,'p':round(u.used/u.total*100,1)})
+                        except: pass
+                    bm >>= 1
+            except: pass
+        else:
+            seen = set()
+            for m in ['/',str(Path.home())]:
+                try:
+                    u = shutil.disk_usage(m)
+                    if u.total not in seen:
+                        seen.add(u.total)
+                        ds.append({'d':m,'t':u.total,'u':u.used,'f':u.free,'p':round(u.used/u.total*100,1)})
+                except: pass
+        return ds
+    
+    @classmethod
+    def large(cls, root, thresh=50*1024*1024, mx=300):
+        r = []
+        for dp,dns,fns in os.walk(root):
+            dns[:] = [d for d in dns if d not in cls.SKIP and not d.startswith('.')]
+            for f in fns:
+                try:
+                    fp = os.path.join(dp,f)
+                    sz = os.path.getsize(fp)
+                    if sz >= thresh:
+                        ext = os.path.splitext(f)[1].lower()
+                        r.append({'p':fp,'s':sz,'n':f,'c':cls.cat(ext)})
+                        if len(r) >= mx: return sorted(r, key=lambda x:x['s'], reverse=True)
+                except: pass
+        return sorted(r, key=lambda x:x['s'], reverse=True)
+    
+    @classmethod
+    def temp_size(cls):
+        paths = [os.environ.get('TEMP','')] if sys.platform=='win32' else ['/tmp',str(Path.home()/'.cache')]
+        t, c = 0, 0
+        for d in paths:
+            if not d or not os.path.exists(d): continue
+            try:
+                for rr,_,fs in os.walk(d):
+                    for f in fs:
+                        try: t += os.path.getsize(os.path.join(rr,f)); c += 1
+                        except: pass
+            except: pass
+        return t, c
+    
+    @classmethod
+    def clean(cls):
+        r = {'del':0,'freed':0}
+        paths = [os.environ.get('TEMP','')] if sys.platform=='win32' else ['/tmp',str(Path.home()/'.cache')]
+        for d in paths:
+            if not d or not os.path.exists(d): continue
+            try:
+                for rr,_,fs in os.walk(d):
+                    for f in fs:
+                        fp = os.path.join(rr,f)
+                        try:
+                            sz = os.path.getsize(fp); os.remove(fp)
+                            r['del'] += 1; r['freed'] += sz
+                        except: pass
+            except: pass
+        return r
+    
+    @classmethod
+    def delete(cls, paths):
+        r = {'del':0,'freed':0}
+        for p in paths:
+            try:
+                sz = os.path.getsize(p) if os.path.isfile(p) else 0
+                if os.path.isfile(p): os.remove(p)
+                elif os.path.isdir(p): shutil.rmtree(p)
+                r['del'] += 1; r['freed'] += sz
+            except: pass
+        return r
+
+
+class Worker(QThread):
+    done = pyqtSignal(object)
+    def __init__(self, fn, *a, **kw):
+        super().__init__()
+        self.fn, self.a, self.kw = fn, a, kw
+    def run(self):
+        self.done.emit(self.fn(*self.a, **self.kw))
+
+
+# ═══════════════════════════════════════════════════════════════
+# ANIMATED WIDGETS
+# ═══════════════════════════════════════════════════════════════
+
+class GlowingBorder(QWidget):
+    """Widget with animated glowing border that cycles colors."""
+    def __init__(self, child_widget, colors=None):
+        super().__init__()
+        self._colors = colors or [C.PINK, C.CYAN, C.PURPLE, C.GOLD]
+        self._phase = 0.0
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._tick)
+        self._timer.start(30)
+        
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(3, 3, 3, 3)
+        layout.addWidget(child_widget)
+    
+    def _tick(self):
+        self._phase += 0.02
+        if self._phase > len(self._colors): self._phase = 0
+        self.update()
+    
+    def paintEvent(self, e):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        
+        # Animated gradient border
+        grad = QConicalGradient(self.width()/2, self.height()/2, self._phase * 60)
+        for i, c in enumerate(self._colors):
+            grad.setColorAt(i / len(self._colors), QColor(c))
+        grad.setColorAt(1.0, QColor(self._colors[0]))
+        
+        pen = QPen(QBrush(grad), 2)
+        p.setPen(pen)
+        p.setBrush(Qt.BrushStyle.NoBrush)
+        p.drawRoundedRect(1, 1, self.width()-2, self.height()-2, 14, 14)
+        p.end()
+
+
+class PulsingDot(QWidget):
+    """Animated pulsing status dot."""
+    def __init__(self, color=C.GREEN, size=12):
+        super().__init__()
+        self.setFixedSize(size*3, size*3)
+        self._color = QColor(color)
+        self._size = size
+        self._pulse = 0.0
+        self._dir = 1
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(30)
+    
+    def _tick(self):
+        self._pulse += 0.04 * self._dir
+        if self._pulse >= 1: self._dir = -1
+        elif self._pulse <= 0: self._dir = 1
+        self.update()
+    
+    def paintEvent(self, e):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        cx, cy = self.width()/2, self.height()/2
+        
+        # Outer pulse
+        c = QColor(self._color)
+        c.setAlpha(int(80 * (1 - self._pulse)))
+        p.setBrush(c)
+        p.setPen(Qt.PenStyle.NoPen)
+        pr = self._size/2 + self._pulse * self._size * 0.8
+        p.drawEllipse(QPointF(cx, cy), pr, pr)
+        
+        # Core
+        p.setBrush(self._color)
+        p.drawEllipse(QPointF(cx, cy), self._size/2, self._size/2)
+        p.end()
+
+
+class AnimatedRing(QWidget):
+    """Big animated ring with glow, gradient, and smooth animation."""
+    def __init__(self, size=200):
+        super().__init__()
+        self.setFixedSize(size, size)
+        self._size = size
+        self._value = 0.0
+        self._target = 0.0
+        self._glow = 0.0
+        self._glow_dir = 1
+        self._rotation = 0.0
+        
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(16)
+    
+    def set_value(self, v):
+        self._target = min(max(v, 0), 100)
+    
+    def _tick(self):
+        # Smooth value
+        self._value += (self._target - self._value) * 0.06
+        # Glow pulse
+        self._glow += 0.03 * self._glow_dir
+        if self._glow >= 1: self._glow_dir = -1
+        elif self._glow <= 0: self._glow_dir = 1
+        # Slow rotation for shimmer
+        self._rotation += 0.3
+        self.update()
+    
+    def paintEvent(self, e):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        s = self._size
+        cx, cy = s/2, s/2
+        thick = 14
+        r = (s - thick*2 - 10) / 2
+        rect = QRectF(cx-r, cy-r, r*2, r*2)
+        
+        # Background ring with subtle glow
+        bg_color = QColor(C.MUTED)
+        bg_color.setAlpha(60)
+        p.setPen(QPen(bg_color, thick, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
+        p.drawArc(rect, 0, 360*16)
+        
+        # Glow behind arc
+        if self._value > 0:
+            glow_color = QColor(C.PINK)
+            glow_color.setAlpha(int(30 + 25 * self._glow))
+            p.setPen(QPen(glow_color, thick + 12, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
+            span = int(self._value / 100 * 360 * 16)
+            p.drawArc(rect, 90*16, -span)
+        
+        # Main arc - gradient
+        if self._value > 0:
+            grad = QConicalGradient(cx, cy, 90 + self._rotation)
+            grad.setColorAt(0, QColor(C.PINK))
+            grad.setColorAt(0.3, QColor(C.PURPLE))
+            grad.setColorAt(0.6, QColor(C.CYAN))
+            grad.setColorAt(1, QColor(C.PINK))
+            p.setPen(QPen(QBrush(grad), thick, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
+            span = int(self._value / 100 * 360 * 16)
+            p.drawArc(rect, 90*16, -span)
+        
+        # Center text
+        p.setPen(QColor(C.WHITE))
+        p.setFont(QFont("Segoe UI", int(s*0.14), QFont.Weight.Bold))
+        p.drawText(rect, Qt.AlignmentFlag.AlignCenter, f"{self._value:.0f}%")
+        
+        # Sub text
+        p.setPen(QColor(C.DIM))
+        p.setFont(QFont("Segoe UI", int(s*0.05)))
+        sub_rect = QRectF(0, cy + s*0.12, s, s*0.1)
+        p.drawText(sub_rect, Qt.AlignmentFlag.AlignCenter, "DISK USED")
+        
+        p.end()
+
+
+class WaveProgress(QWidget):
+    """Animated wave progress bar with liquid effect."""
+    def __init__(self, height=30):
+        super().__init__()
+        self.setFixedHeight(height)
+        self._value = 0.0
+        self._target = 0.0
+        self._wave_phase = 0.0
+        self._color1 = C.PINK
+        self._color2 = C.PURPLE
+        
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(30)
+    
+    def set_value(self, v, c1=None, c2=None):
+        self._target = min(max(v, 0), 100)
+        if c1: self._color1 = c1
+        if c2: self._color2 = c2
+    
+    def _tick(self):
+        self._value += (self._target - self._value) * 0.08
+        self._wave_phase += 0.1
+        self.update()
+    
+    def paintEvent(self, e):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        w, h = self.width(), self.height()
+        
+        # Background
+        p.setBrush(QColor(C.MUTED))
+        p.setPen(Qt.PenStyle.NoPen)
+        p.drawRoundedRect(0, 0, w, h, h/2, h/2)
+        
+        # Fill with wave
+        fill_w = int(w * self._value / 100)
+        if fill_w > 0:
+            # Gradient fill
+            grad = QLinearGradient(0, 0, fill_w, 0)
+            grad.setColorAt(0, QColor(self._color1))
+            grad.setColorAt(1, QColor(self._color2))
+            
+            # Create wave path
+            path = QPainterPath()
+            path.moveTo(0, h)
+            path.lineTo(0, 0)
+            
+            # Wave on top edge
+            for x in range(fill_w):
+                wave_y = math.sin(x * 0.05 + self._wave_phase) * 2
+                path.lineTo(x, h/2 + wave_y - h*0.3)
+            
+            path.lineTo(fill_w, h)
+            path.closeSubpath()
+            
+            # Clip to rounded rect
+            clip_path = QPainterPath()
+            clip_path.addRoundedRect(QRectF(0, 0, w, h), h/2, h/2)
+            p.setClipPath(clip_path)
+            
+            p.setBrush(QBrush(grad))
+            p.drawPath(path)
+            
+            # Second wave layer (lighter)
+            path2 = QPainterPath()
+            path2.moveTo(0, h)
+            path2.lineTo(0, h*0.6)
+            for x in range(fill_w):
+                wave_y = math.sin(x * 0.04 + self._wave_phase * 1.3 + 1) * 3
+                path2.lineTo(x, h/2 + wave_y)
+            path2.lineTo(fill_w, h)
+            path2.closeSubpath()
+            
+            c = QColor(self._color2)
+            c.setAlpha(100)
+            p.setBrush(c)
+            p.drawPath(path2)
+            
+            p.setClipping(False)
+        
+        # Text
+        p.setPen(QColor(C.WHITE if self._value > 30 else C.TEXT))
+        p.setFont(QFont("Segoe UI", 9, QFont.Weight.Bold))
+        p.drawText(QRect(0, 0, w, h), Qt.AlignmentFlag.AlignCenter, f"{self._value:.0f}%")
+        p.end()
+
+
+class NeonButton(QPushButton):
+    """Button with neon glow animation on hover."""
+    def __init__(self, text, color=C.PINK, parent=None):
+        super().__init__(text, parent)
+        self._color = color
+        self._glow = 0.0
+        self._hover = False
+        self.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.setFixedHeight(42)
+        self.setFont(QFont("Segoe UI", 11, QFont.Weight.Bold))
+        
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(20)
+    
+    def _tick(self):
+        target = 1.0 if self._hover else 0.0
+        self._glow += (target - self._glow) * 0.15
+        self.update()
+    
+    def enterEvent(self, e): self._hover = True
+    def leaveEvent(self, e): self._hover = False
+    
+    def paintEvent(self, e):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        w, h = self.width(), self.height()
+        
+        # Glow shadow
+        if self._glow > 0.01:
+            glow_c = QColor(self._color)
+            glow_c.setAlpha(int(60 * self._glow))
+            p.setBrush(glow_c)
+            p.setPen(Qt.PenStyle.NoPen)
+            p.drawRoundedRect(QRectF(-4, -2, w+8, h+6), 14, 14)
+        
+        # Background
+        grad = QLinearGradient(0, 0, w, 0)
+        c1 = QColor(self._color)
+        c2 = QColor(self._color).lighter(130)
+        if self._glow > 0.5:
+            c1 = c1.lighter(int(110 + 20*self._glow))
+        grad.setColorAt(0, c1)
+        grad.setColorAt(1, c2)
+        
+        p.setBrush(QBrush(grad))
+        p.setPen(Qt.PenStyle.NoPen)
+        p.drawRoundedRect(QRectF(0, 0, w, h), 10, 10)
+        
+        # Shimmer line
+        if self._glow > 0.3:
+            shimmer_x = (self._glow * 2 % 1) * w
+            shimmer_grad = QLinearGradient(shimmer_x - 30, 0, shimmer_x + 30, 0)
+            shimmer_grad.setColorAt(0, QColor(255, 255, 255, 0))
+            shimmer_grad.setColorAt(0.5, QColor(255, 255, 255, int(40 * self._glow)))
+            shimmer_grad.setColorAt(1, QColor(255, 255, 255, 0))
+            p.setBrush(QBrush(shimmer_grad))
+            clip = QPainterPath()
+            clip.addRoundedRect(QRectF(0, 0, w, h), 10, 10)
+            p.setClipPath(clip)
+            p.drawRect(0, 0, w, h)
+            p.setClipping(False)
+        
+        # Text
+        p.setPen(QColor(C.WHITE))
+        p.setFont(self.font())
+        p.drawText(QRect(0, 0, w, h), Qt.AlignmentFlag.AlignCenter, self.text())
+        p.end()
+
+
+class FloatingParticles(QWidget):
+    """Background particles that float and connect with lines."""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+        self._particles = []
+        for _ in range(40):
+            self._particles.append({
+                'x': random.random(), 'y': random.random(),
+                'vx': (random.random()-0.5)*0.0008, 'vy': (random.random()-0.5)*0.0008,
+                'size': random.uniform(1.5, 4),
+                'alpha': random.randint(15, 50),
+                'color': random.choice([C.PINK, C.CYAN, C.GOLD, C.PURPLE]),
+            })
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(33)
+    
+    def _tick(self):
+        for p in self._particles:
+            p['x'] += p['vx']; p['y'] += p['vy']
+            if p['x'] < 0 or p['x'] > 1: p['vx'] *= -1
+            if p['y'] < 0 or p['y'] > 1: p['vy'] *= -1
+        self.update()
+    
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        w, h = self.width(), self.height()
+        
+        # Draw connection lines between nearby particles
+        for i, p1 in enumerate(self._particles):
+            for p2 in self._particles[i+1:]:
+                dx = (p1['x'] - p2['x']) * w
+                dy = (p1['y'] - p2['y']) * h
+                dist = math.sqrt(dx*dx + dy*dy)
+                if dist < 120:
+                    alpha = int(20 * (1 - dist/120))
+                    c = QColor(C.CYAN)
+                    c.setAlpha(alpha)
+                    painter.setPen(QPen(c, 0.5))
+                    painter.drawLine(QPointF(p1['x']*w, p1['y']*h), QPointF(p2['x']*w, p2['y']*h))
+        
+        # Draw particles
+        for p in self._particles:
+            c = QColor(p['color'])
+            c.setAlpha(p['alpha'])
+            painter.setBrush(c)
+            painter.setPen(Qt.PenStyle.NoPen)
+            painter.drawEllipse(QPointF(p['x']*w, p['y']*h), p['size'], p['size'])
+        
+        painter.end()
+
+
+class AnimatedCard(QFrame):
+    """Card with hover lift animation and border glow."""
+    def __init__(self):
+        super().__init__()
+        self._hover = False
+        self._lift = 0.0
+        self.setStyleSheet(f"background-color: {C.CARD}; border: 1px solid {C.BORDER}; border-radius: 14px;")
+        
+        shadow = QGraphicsDropShadowEffect()
+        shadow.setBlurRadius(15)
+        shadow.setColor(QColor(0, 0, 0, 60))
+        shadow.setOffset(0, 4)
+        self.setGraphicsEffect(shadow)
+        
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(20)
+    
+    def _tick(self):
+        target = 1.0 if self._hover else 0.0
+        old = self._lift
+        self._lift += (target - self._lift) * 0.15
+        if abs(old - self._lift) > 0.01:
+            effect = self.graphicsEffect()
+            if effect:
+                effect.setBlurRadius(15 + self._lift * 20)
+                effect.setOffset(0, 4 - self._lift * 3)
+                effect.setColor(QColor(int(255*0.1*self._lift), 0, int(100*self._lift), int(60 + 40*self._lift)))
+    
+    def enterEvent(self, e): self._hover = True
+    def leaveEvent(self, e): self._hover = False
+
+
+class GlowText(QLabel):
+    """Label with animated neon text glow."""
+    def __init__(self, text, color=C.GOLD, size=24):
+        super().__init__(text)
+        self._color = color
+        self._glow = 0.0
+        self._dir = 1
+        self.setFont(QFont("Segoe UI", size, QFont.Weight.Bold))
+        self.setStyleSheet(f"color: {color}; background: transparent; border: none;")
+        
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(40)
+    
+    def _tick(self):
+        self._glow += 0.03 * self._dir
+        if self._glow >= 1: self._dir = -1
+        elif self._glow <= 0: self._dir = 1
+        
+        # Update text shadow via stylesheet
+        blur = int(8 + 12 * self._glow)
+        self.setStyleSheet(f"color: {self._color}; background: transparent; border: none; text-shadow: 0 0 {blur}px {self._color};")
+
+
+class LiveStatCard(AnimatedCard):
+    """Stat card with animated counting value and glow icon."""
+    def __init__(self, icon, label, color):
+        super().__init__()
+        self.setFixedHeight(90)
+        self.setMinimumWidth(170)
+        self._color = color
+        self._display_value = 0.0
+        self._target_value = 0.0
+        self._text_value = "---"
+        
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(16, 12, 16, 12)
+        
+        # Pulsing icon
+        icon_w = QWidget()
+        icon_w.setFixedSize(44, 44)
+        icon_w.setStyleSheet(f"background: qradialgradient(cx:0.5,cy:0.5,radius:0.5, stop:0 {color}40, stop:1 {color}10); border-radius: 22px; border: none;")
+        il = QVBoxLayout(icon_w)
+        il.setContentsMargins(0, 0, 0, 0)
+        ic = QLabel(icon)
+        ic.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        ic.setStyleSheet(f"font-size: 20px; border: none; background: transparent;")
+        il.addWidget(ic)
+        layout.addWidget(icon_w)
+        
+        # Text
+        tl = QVBoxLayout()
+        tl.setSpacing(2)
+        self._val_label = QLabel("---")
+        self._val_label.setFont(QFont("Segoe UI", 18, QFont.Weight.Bold))
+        self._val_label.setStyleSheet(f"color: {color}; border: none; background: transparent;")
+        tl.addWidget(self._val_label)
+        
+        ll = QLabel(label)
+        ll.setStyleSheet(f"color: {C.DIM}; font-size: 10px; border: none; background: transparent;")
+        tl.addWidget(ll)
+        layout.addLayout(tl)
+        layout.addStretch()
+    
+    def set_value(self, text):
+        self._val_label.setText(text)
+
+
+# ═══════════════════════════════════════════════════════════════
+# TITLE BAR
+# ═══════════════════════════════════════════════════════════════
+
+class TitleBar(QWidget):
+    def __init__(self, win):
+        super().__init__()
+        self._win = win
+        self._drag = None
+        self.setFixedHeight(44)
+        self.setStyleSheet(f"background: {C.BG}; border-bottom: 1px solid {C.MUTED};")
+        
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(14, 0, 8, 0)
+        
+        # Animated dot
+        self._dot = PulsingDot(C.PINK, 6)
+        layout.addWidget(self._dot)
+        
+        title = QLabel("MoneyPackCleaner")
+        title.setFont(QFont("Segoe UI", 11, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {C.GOLD}; border: none; background: transparent;")
+        layout.addWidget(title)
+        
+        tag = QLabel("ELITE")
+        tag.setStyleSheet(f"color: {C.PINK}; font-size: 8px; font-weight: bold; letter-spacing: 2px; border: none; background: transparent; padding-top: 2px;")
+        layout.addWidget(tag)
+        
+        layout.addStretch()
+        
+        for txt, color, act in [("\u2014", C.DIM, win.showMinimized), ("\u25a1", C.DIM, self._max), ("\u2715", C.RED, win.close)]:
+            b = QPushButton(txt)
+            b.setFixedSize(36, 30)
+            b.setStyleSheet(f"QPushButton {{ background: transparent; color: {color}; border: none; font-size: 13px; border-radius: 5px; }} QPushButton:hover {{ background: {C.HOVER}; color: {C.WHITE}; }}")
+            b.clicked.connect(act)
+            layout.addWidget(b)
+    
+    def _max(self):
+        if self._win.isMaximized(): self._win.showNormal()
+        else: self._win.showMaximized()
+    
+    def mousePressEvent(self, e):
+        if e.button() == Qt.MouseButton.LeftButton:
+            self._drag = e.globalPosition().toPoint() - self._win.frameGeometry().topLeft()
+    def mouseMoveEvent(self, e):
+        if self._drag and e.buttons() == Qt.MouseButton.LeftButton:
+            self._win.move(e.globalPosition().toPoint() - self._drag)
+    def mouseReleaseEvent(self, e): self._drag = None
+    def mouseDoubleClickEvent(self, e): self._max()
+
+
+# ═══════════════════════════════════════════════════════════════
+# SIDEBAR
+# ═══════════════════════════════════════════════════════════════
+
+class NavButton(QPushButton):
+    def __init__(self, icon, label, idx):
+        super().__init__()
+        self.idx = idx
+        self._icon = icon
+        self._label = label
+        self._active = False
+        self._hover = False
+        self._glow = 0.0
+        self.setFixedHeight(50)
+        self.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.setStyleSheet("border: none; background: transparent;")
+        t = QTimer(self)
+        t.timeout.connect(self._tick)
+        t.start(20)
+    
+    def set_active(self, a): self._active = a; self.update()
+    def enterEvent(self, e): self._hover = True
+    def leaveEvent(self, e): self._hover = False
+    
+    def _tick(self):
+        target = 1.0 if (self._active or self._hover) else 0.0
+        self._glow += (target - self._glow) * 0.12
+        self.update()
+    
+    def paintEvent(self, e):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        w, h = self.width(), self.height()
+        
+        # Background glow
+        if self._glow > 0.01:
+            c = QColor(C.PINK if self._active else C.CYAN)
+            c.setAlpha(int(25 * self._glow))
+            p.setBrush(c)
+            p.setPen(Qt.PenStyle.NoPen)
+            p.drawRoundedRect(QRectF(4, 2, w-8, h-4), 10, 10)
+        
+        # Active bar
+        if self._active:
+            grad = QLinearGradient(0, 0, 0, h)
+            grad.setColorAt(0, QColor(C.PINK))
+            grad.setColorAt(1, QColor(C.PURPLE))
+            p.setBrush(QBrush(grad))
+            p.setPen(Qt.PenStyle.NoPen)
+            p.drawRoundedRect(QRectF(0, 8, 3, h-16), 2, 2)
+        
+        # Icon
+        p.setPen(QColor(C.PINK if self._active else (C.TEXT if self._hover else C.DIM)))
+        p.setFont(QFont("Segoe UI Emoji", 16))
+        p.drawText(QRect(18, 0, 30, h), Qt.AlignmentFlag.AlignVCenter, self._icon)
+        
+        # Label
+        p.setPen(QColor(C.WHITE if self._active else (C.TEXT if self._hover else C.DIM)))
+        p.setFont(QFont("Segoe UI", 11, QFont.Weight.Bold if self._active else QFont.Weight.Normal))
+        p.drawText(QRect(54, 0, w-60, h), Qt.AlignmentFlag.AlignVCenter, self._label)
+        p.end()
+
+
+class Sidebar(QWidget):
+    changed = pyqtSignal(int)
+    def __init__(self):
+        super().__init__()
+        self.setFixedWidth(200)
+        self.setStyleSheet(f"background: {C.BG2}; border-right: 1px solid {C.MUTED};")
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 12, 0, 12)
+        layout.setSpacing(0)
+        
+        # Brand
+        brand = QHBoxLayout()
+        brand.setContentsMargins(16, 8, 0, 16)
+        dot = QLabel()
+        dot.setFixedSize(28, 28)
+        dot.setStyleSheet(f"background: qlineargradient(x1:0,y1:0,x2:1,y2:1, stop:0 {C.PINK}, stop:1 {C.GOLD}); border-radius: 14px; border: none;")
+        brand.addWidget(dot)
+        bl = QVBoxLayout()
+        bl.setSpacing(0)
+        bn = QLabel("MoneyPack")
+        bn.setFont(QFont("Segoe UI", 11, QFont.Weight.Bold))
+        bn.setStyleSheet(f"color: {C.GOLD}; border: none; background: transparent;")
+        bl.addWidget(bn)
+        bs = QLabel("ELITE")
+        bs.setStyleSheet(f"color: {C.PINK}; font-size: 8px; letter-spacing: 3px; border: none; background: transparent;")
+        bl.addWidget(bs)
+        brand.addLayout(bl)
+        brand.addStretch()
+        layout.addLayout(brand)
+        
+        layout.addSpacing(10)
+        
+        self._btns = []
+        for i, (icon, label) in enumerate([("🏠","Dashboard"),("📁","Large Files"),("🧹","Clean"),("📊","Log")]):
+            btn = NavButton(icon, label, i)
+            btn.clicked.connect(lambda _, idx=i: self._click(idx))
+            layout.addWidget(btn)
+            self._btns.append(btn)
+        
+        layout.addStretch()
+        v = QLabel(f"v{APP_VERSION}")
+        v.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        v.setStyleSheet(f"color: {C.MUTED}; font-size: 9px; border: none; background: transparent;")
+        layout.addWidget(v)
+        
+        self._btns[0].set_active(True)
+    
+    def _click(self, idx):
+        for b in self._btns: b.set_active(b.idx == idx)
+        self.changed.emit(idx)
+
+
+# ═══════════════════════════════════════════════════════════════
+# PAGES
+# ═══════════════════════════════════════════════════════════════
+
+class DashPage(QWidget):
+    log = pyqtSignal(str)
+    def __init__(self):
+        super().__init__()
+        self.setStyleSheet("background: transparent; border: none;")
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(28, 28, 28, 28)
+        layout.setSpacing(20)
+        
+        # Header
+        h = QHBoxLayout()
+        self._title = GlowText("Dashboard", C.GOLD, 22)
+        h.addWidget(self._title)
+        h.addStretch()
+        
+        qb = NeonButton("  Quick Clean  ", C.PINK)
+        qb.clicked.connect(self._quick)
+        h.addWidget(qb)
+        layout.addLayout(h)
+        
+        # Stats
+        stats = QHBoxLayout()
+        stats.setSpacing(14)
+        self.c_total = LiveStatCard("💾","Total Storage", C.CYAN)
+        self.c_used = LiveStatCard("📊","Used", C.PINK)
+        self.c_free = LiveStatCard("✨","Free", C.GREEN)
+        self.c_temp = LiveStatCard("🗑","Cleanable", C.YELLOW)
+        stats.addWidget(self.c_total)
+        stats.addWidget(self.c_used)
+        stats.addWidget(self.c_free)
+        stats.addWidget(self.c_temp)
+        layout.addLayout(stats)
+        
+        # Ring + drives
+        mid = QHBoxLayout()
+        mid.setSpacing(20)
+        
+        ring_card = AnimatedCard()
+        rl = QVBoxLayout(ring_card)
+        rl.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.ring = AnimatedRing(200)
+        rl.addWidget(self.ring, alignment=Qt.AlignmentFlag.AlignCenter)
+        mid.addWidget(ring_card)
+        
+        # Drive bars
+        drive_card = AnimatedCard()
+        dl = QVBoxLayout(drive_card)
+        dl.setContentsMargins(16, 16, 16, 16)
+        dl.setSpacing(12)
+        dtitle = QLabel("Drives")
+        dtitle.setStyleSheet(f"color: {C.DIM}; font-size: 11px; font-weight: bold; border: none; background: transparent;")
+        dl.addWidget(dtitle)
+        self._drive_bars = []
+        for _ in range(4):
+            row = QHBoxLayout()
+            lbl = QLabel("---")
+            lbl.setFixedWidth(50)
+            lbl.setStyleSheet(f"color: {C.TEXT}; border: none; background: transparent; font-size: 11px;")
+            row.addWidget(lbl)
+            bar = WaveProgress(24)
+            row.addWidget(bar)
+            dl.addLayout(row)
+            self._drive_bars.append((lbl, bar))
+        dl.addStretch()
+        mid.addWidget(drive_card)
+        
+        layout.addLayout(mid)
+        layout.addStretch()
+        self.refresh()
+    
+    def refresh(self):
+        disks = E.disks()
+        total = sum(d['t'] for d in disks)
+        used = sum(d['u'] for d in disks)
+        free = sum(d['f'] for d in disks)
+        
+        self.c_total.set_value(format_size(total))
+        self.c_used.set_value(format_size(used))
+        self.c_free.set_value(format_size(free))
+        
+        tsz, _ = E.temp_size()
+        self.c_temp.set_value(format_size(tsz))
+        
+        pct = round(used/total*100, 1) if total else 0
+        self.ring.set_value(pct)
+        
+        for i, d in enumerate(disks[:4]):
+            lbl, bar = self._drive_bars[i]
+            lbl.setText(d['d'])
+            c1 = C.GREEN if d['p'] < 60 else (C.YELLOW if d['p'] < 85 else C.RED)
+            c2 = C.CYAN if d['p'] < 60 else (C.GOLD if d['p'] < 85 else C.PINK)
+            bar.set_value(d['p'], c1, c2)
+    
+    def _quick(self):
+        r = E.clean()
+        self.log.emit(f"Quick clean: {r['del']} files, {format_size(r['freed'])} freed")
+        self.refresh()
+
+
+class FilesPage(QWidget):
+    log = pyqtSignal(str)
+    def __init__(self):
+        super().__init__()
+        self.setStyleSheet("background: transparent; border: none;")
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(28, 28, 28, 28)
+        layout.setSpacing(12)
+        
+        layout.addWidget(GlowText("Large Files", C.GOLD, 20))
+        
+        ctrl = QHBoxLayout()
+        self.path = QLineEdit(str(Path.home()))
+        self.path.setStyleSheet(f"background: {C.CARD}; border: 1px solid {C.MUTED}; border-radius: 10px; padding: 10px 14px; color: {C.TEXT}; font-size: 12px;")
+        ctrl.addWidget(self.path)
+        
+        bb = NeonButton("Browse", C.PURPLE)
+        bb.setFixedWidth(100)
+        bb.clicked.connect(lambda: self.path.setText(QFileDialog.getExistingDirectory(self) or self.path.text()))
+        ctrl.addWidget(bb)
+        
+        sb = NeonButton("Scan", C.CYAN)
+        sb.setFixedWidth(100)
+        sb.clicked.connect(self._scan)
+        ctrl.addWidget(sb)
+        layout.addLayout(ctrl)
+        
+        self.tree = QTreeWidget()
+        self.tree.setHeaderLabels(["File","Size","Type","Path"])
+        self.tree.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        self.tree.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self.tree.setStyleSheet(f"""
+            QTreeWidget {{ background: {C.PANEL}; border: 1px solid {C.MUTED}; border-radius: 10px; color: {C.TEXT}; alternate-background-color: {C.BG2}; }}
+            QTreeWidget::item {{ padding: 4px; }}
+            QTreeWidget::item:selected {{ background: {C.HOVER}; }}
+            QTreeWidget::item:hover {{ background: {C.CARD}; }}
+            QHeaderView::section {{ background: {C.BG2}; color: {C.DIM}; border: none; padding: 8px; font-weight: bold; font-size: 10px; }}
+        """)
+        self.tree.setAlternatingRowColors(True)
+        layout.addWidget(self.tree)
+        
+        bottom = QHBoxLayout()
+        self.status = QLabel("Ready")
+        self.status.setStyleSheet(f"color: {C.DIM}; border: none; background: transparent;")
+        bottom.addWidget(self.status)
+        bottom.addStretch()
+        db = NeonButton("Delete Selected", C.RED)
+        db.setFixedWidth(160)
+        db.clicked.connect(self._del)
+        bottom.addWidget(db)
+        layout.addLayout(bottom)
+        self._w = None
+    
+    def _scan(self):
+        self.tree.clear()
+        self.status.setText("Scanning...")
+        self._w = Worker(E.large, self.path.text())
+        self._w.done.connect(self._done)
+        self._w.start()
+    
+    def _done(self, results):
+        colors = {'Video':C.RED,'Audio':C.YELLOW,'Image':C.GREEN,'Archive':C.PURPLE,'Installer':C.PINK,'Document':C.CYAN}
+        total = sum(r['s'] for r in results)
+        for r in results:
+            item = QTreeWidgetItem()
+            item.setText(0, r['n'])
+            item.setText(1, format_size(r['s']))
+            item.setText(2, r['c'])
+            item.setText(3, r['p'])
+            item.setData(0, Qt.ItemDataRole.UserRole, r['p'])
+            item.setForeground(2, QColor(colors.get(r['c'], C.DIM)))
+            self.tree.addTopLevelItem(item)
+        self.status.setText(f"{len(results)} files ({format_size(total)})")
+        self.log.emit(f"Found {len(results)} large files ({format_size(total)})")
+    
+    def _del(self):
+        items = self.tree.selectedItems()
+        if not items: return
+        paths = [i.data(0, Qt.ItemDataRole.UserRole) for i in items]
+        if QMessageBox.question(self,"Delete",f"Delete {len(paths)} files?") == QMessageBox.StandardButton.Yes:
+            r = E.delete(paths)
+            self.log.emit(f"Deleted {r['del']}, freed {format_size(r['freed'])}")
+            self._scan()
+
+
+class CleanPage(QWidget):
+    log = pyqtSignal(str)
+    def __init__(self):
+        super().__init__()
+        self.setStyleSheet("background: transparent; border: none;")
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(28, 28, 28, 28)
+        layout.setSpacing(16)
+        
+        layout.addWidget(GlowText("System Cleaner", C.GOLD, 20))
+        
+        self.info = QLabel("Analyzing...")
+        self.info.setStyleSheet(f"color: {C.TEXT}; border: none; background: transparent; font-size: 13px;")
+        layout.addWidget(self.info)
+        
+        card = AnimatedCard()
+        cl = QVBoxLayout(card)
+        cl.setContentsMargins(20, 20, 20, 20)
+        cl.setSpacing(14)
+        for text in ["Temporary Files","Recycle Bin / Trash","Browser Cache","Thumbnail Cache"]:
+            cb = QCheckBox(text)
+            cb.setChecked(True)
+            cb.setStyleSheet(f"QCheckBox {{ color: {C.TEXT}; spacing: 10px; border: none; background: transparent; font-size: 12px; }} QCheckBox::indicator {{ width: 22px; height: 22px; border: 2px solid {C.MUTED}; border-radius: 6px; background: {C.PANEL}; }} QCheckBox::indicator:checked {{ background: qlineargradient(x1:0,y1:0,x2:1,y2:1, stop:0 {C.PINK}, stop:1 {C.PURPLE}); border-color: {C.PINK}; }}")
+            cl.addWidget(cb)
+        layout.addWidget(card)
+        
+        # Big clean button
+        clean_btn = NeonButton("    CLEAN NOW    ", C.PINK)
+        clean_btn.setFixedHeight(52)
+        clean_btn.setFont(QFont("Segoe UI", 14, QFont.Weight.Bold))
+        clean_btn.clicked.connect(self._clean)
+        layout.addWidget(clean_btn)
+        
+        self.result = QLabel("")
+        self.result.setStyleSheet(f"color: {C.GREEN}; border: none; background: transparent; font-size: 14px; font-weight: bold;")
+        layout.addWidget(self.result)
+        layout.addStretch()
+        QTimer.singleShot(500, self._analyze)
+    
+    def _analyze(self):
+        sz, cnt = E.temp_size()
+        self.info.setText(f"Found {cnt:,} cleanable files ({format_size(sz)})")
+    
+    def _clean(self):
+        if QMessageBox.question(self,"Clean","Clean all selected?") == QMessageBox.StandardButton.Yes:
+            r = E.clean()
+            self.result.setText(f"Cleaned {r['del']:,} files | Freed {format_size(r['freed'])}")
+            self.log.emit(f"Cleaned {r['del']} files, freed {format_size(r['freed'])}")
+            QTimer.singleShot(1000, self._analyze)
+
+
+class LogPage(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setStyleSheet("background: transparent; border: none;")
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(28, 28, 28, 28)
+        layout.addWidget(GlowText("Activity Log", C.GOLD, 20))
+        self.log = QTextEdit()
+        self.log.setReadOnly(True)
+        self.log.setFont(QFont("JetBrains Mono", 10))
+        self.log.setStyleSheet(f"background: {C.PANEL}; border: 1px solid {C.MUTED}; border-radius: 10px; color: {C.TEXT}; padding: 10px;")
+        layout.addWidget(self.log)
+        self.add("MoneyPackCleaner ELITE started")
+    
+    def add(self, msg):
+        ts = datetime.now().strftime("%H:%M:%S")
+        self.log.append(f"<span style='color:{C.DIM}'>[{ts}]</span> <span style='color:{C.CYAN}'>&gt;</span> <span style='color:{C.TEXT}'>{msg}</span>")
+
+
+# ═══════════════════════════════════════════════════════════════
+# MAIN WINDOW
+# ═══════════════════════════════════════════════════════════════
+
+class MoneyPackElite(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("MoneyPackCleaner ELITE")
+        self.setMinimumSize(1100, 700)
+        self.resize(1300, 800)
+        self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
+        self.setStyleSheet(f"QMainWindow {{ background: {C.BG}; }}")
+        
+        container = QWidget()
+        self.setCentralWidget(container)
+        ml = QVBoxLayout(container)
+        ml.setContentsMargins(0, 0, 0, 0)
+        ml.setSpacing(0)
+        
+        # Titlebar
+        ml.addWidget(TitleBar(self))
+        
+        # Body
+        body = QHBoxLayout()
+        body.setContentsMargins(0, 0, 0, 0)
+        body.setSpacing(0)
+        
+        # Sidebar
+        self.sidebar = Sidebar()
+        self.sidebar.changed.connect(self._nav)
+        body.addWidget(self.sidebar)
+        
+        # Content
+        content = QWidget()
+        content.setStyleSheet(f"background: {C.BG};")
+        cl = QVBoxLayout(content)
+        cl.setContentsMargins(0, 0, 0, 0)
+        
+        # Particles
+        self.particles = FloatingParticles(content)
+        
+        # Stack
+        self.stack = QStackedWidget()
+        self.stack.setStyleSheet("background: transparent;")
+        
+        self.dash = DashPage()
+        self.files = FilesPage()
+        self.clean = CleanPage()
+        self.logp = LogPage()
+        
+        self.stack.addWidget(self.dash)
+        self.stack.addWidget(self.files)
+        self.stack.addWidget(self.clean)
+        self.stack.addWidget(self.logp)
+        
+        cl.addWidget(self.stack)
+        body.addWidget(content)
+        ml.addLayout(body)
+        
+        # Connect logs
+        for pg in [self.dash, self.files, self.clean]:
+            pg.log.connect(self.logp.add)
+        
+        # Tray
+        self._tray_setup()
+    
+    def _nav(self, idx):
+        self.stack.setCurrentIndex(idx)
+    
+    def _tray_setup(self):
+        if not QSystemTrayIcon.isSystemTrayAvailable(): return
+        pix = QPixmap(32,32)
+        pix.fill(QColor(0,0,0,0))
+        pa = QPainter(pix)
+        pa.setRenderHint(QPainter.RenderHint.Antialiasing)
+        grad = QLinearGradient(0,0,32,32)
+        grad.setColorAt(0, QColor(C.PINK))
+        grad.setColorAt(1, QColor(C.GOLD))
+        pa.setBrush(QBrush(grad))
+        pa.setPen(Qt.PenStyle.NoPen)
+        pa.drawEllipse(2,2,28,28)
+        pa.setPen(QColor(C.WHITE))
+        pa.setFont(QFont("Segoe UI",13,QFont.Weight.Bold))
+        pa.drawText(QRect(0,0,32,32), Qt.AlignmentFlag.AlignCenter, "M")
+        pa.end()
+        self._tray = QSystemTrayIcon(QIcon(pix), self)
+        self._tray.setToolTip("MoneyPackCleaner ELITE")
+        menu = QMenu()
+        menu.addAction("Show", self.show)
+        menu.addAction("Quick Clean", self.dash._quick)
+        menu.addSeparator()
+        menu.addAction("Exit", QApplication.quit)
+        self._tray.setContextMenu(menu)
+        self._tray.show()
+    
+    def resizeEvent(self, e):
+        super().resizeEvent(e)
+        if hasattr(self, 'particles'):
+            self.particles.resize(self.width()-200, self.height()-44)
+            self.particles.move(200, 44)
+    
+    def closeEvent(self, e):
+        if hasattr(self, '_tray') and self._tray.isVisible():
+            self.hide(); e.ignore()
+        else: e.accept()
+
+
+# ═══════════════════════════════════════════════════════════════
+# ENTRY
+# ═══════════════════════════════════════════════════════════════
+
+def main():
+    app = QApplication(sys.argv)
+    app.setFont(QFont("Segoe UI", 10))
+    w = MoneyPackElite()
+    w.show()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()