feat: Added a loading screen to prevent info blackout at start, less schizo shit, better cpu delta calc (using EMA values)

Author: ThatOneFBIAgent

WinHtop-Setup.exe

@@ -333,4 +333,6 @@ def get_magnitudes(self):
     @property
     def is_running(self):
         """Check if audio capture is active."""
-        return self._running
+        return self._running
+
+# dont ask how many hours were spent on a FUCKING easter egg of all things

dist/winhtop.exe

@@ -132,6 +132,17 @@ def get_hardware_info():
 
     $chosen
     '''
+    # powershell command breakdown:
+    # 1- get disk info for letter 'c' drives
+    # 2- get partition info for disk
+    # 3- get disk info for partition
+    # 4- select first disk
+    # 5- get friendly name (if exists)
+    # 6- get model, get bus type, get size
+    # 7- get chosen name
+    # 8- if no chosen name, use disk info
+    # 9- if chosen name is less than 8 chars, add bus type and size
+    # 10- return chosen name
 
     try:
         result = subprocess.run(

modules/audio_vis.py

@@ -308,4 +308,5 @@ def handle_input():
         elif ch == '\x03':
             state.app_running = False
         elif ch.isprintable():
-            state.input_buffer += ch
+            if len(state.input_buffer) < 120:
+                state.input_buffer += ch

modules/hardware.py

@@ -85,27 +85,8 @@ def get_process_tree_info(targets):
     tree_lines = []
     parent_groups = {}  # parent_pid -> list of child processes
 
-    # Recalculate full list for tree building if needed, or search current state.processes?
-    # get_process_tree_info takes 'targets' which are psutil.Process objects usually...
-    # Wait, 'targets' in ui.py or input.py might be passed as PID or dict?
-    # In pending_confirmation, targets is list of dicts or objects.
-    # We need to verify what 'targets' contains.
-    # Since we replaced get_processes, state.processes now contains dicts, not psutil.Process objects.
-    # Previous code: procs.append(pinfo) -> pinfo was dict (proc.info.copy()).
-    # So targets is list of dicts.
-    
-    # However, get_process_tree_info implementation in original used p.ppid() which implies p is psutil.Process?
-    # Let's check the original code again.
-    # "for p in targets: try: ppid = p.ppid() ..."
-    # "procs.append(pinfo)" where pinfo is dict.
-    # Ah, the `targets` passed to `get_process_tree_info` might come from `state.pending_confirmation`? 
-    # Let's assume we need to handle dicts now, or re-instantiate psutil objects.
-    # The user asked for "Displaying the entire process tree...".
-    
-    # If targets contains dicts from our new get_processes, they have 'pid' and 'ppid' (we added ppid in processsn return).
-    # processsn.compute_cpu_deltas returns list of dicts WITH 'ppid'.
-    # So we can use that.
-    
+    # targets consists of process info dicts (including 'ppid') from the native snapshot
+    # instead of psutil.Process objects to maintain performance and consistency.
     for p in targets:
         # p is dict
         try:
@@ -118,8 +99,6 @@ def get_process_tree_info(targets):
         except:
             pass
 
-    # We need to look up parent names.
-    # We can use state.processes to find names of parents!
     # Map pid -> name
     proc_map = {proc['pid']: proc['name'] for proc in state.processes}
 

modules/input.py

@@ -1,12 +1,17 @@
 """Process info/list module using native windows APIs"""
 import ctypes
 import ctypes.wintypes as wt
+import time
 
 # Windows types for NtQuerySystemInformation
 ntdll = ctypes.WinDLL("ntdll")
 
 SystemProcessInformation = 5
 
+# Cache for EMA values
+_last_snapshot_time = None
+_ema_cache = {}
+
 class UNICODE_STRING(ctypes.Structure):
     _fields_ = [
         ("Length", wt.WORD),
@@ -21,7 +26,7 @@ class SYSTEM_THREAD_INFORMATION(ctypes.Structure):
         ("CreateTime", wt.LARGE_INTEGER),
         ("WaitTime", wt.ULONG),
         ("StartAddress", wt.LPVOID),
-        ("ClientId", wt.LARGE_INTEGER * 1),  # not used here
+        ("ClientId", wt.LARGE_INTEGER * 1),  # not used here but we take anyway
         ("Priority", wt.LONG),
         ("BasePriority", wt.LONG),
         ("ContextSwitches", wt.ULONG),
@@ -112,7 +117,7 @@ def get_native_process_snapshot():
             continue
 
         if ret != 0:
-            raise OSError("NtQuerySystemInformation failed")
+            raise OSError("NtQuerySystemInformation failed, WinHTop is unable to retrieve process information")
 
         break
 
@@ -172,52 +177,61 @@ def compute_cpu_deltas(prev_cache, curr_snapshot, interval_seconds, cpu_count):
         list[dict]:
             proc_list with computed stats
     """
+    global _last_snapshot_time
+    smoothing_factor = 0.2
     results = []
 
-    # Clamp interval to avoid division by zero or noisy spikes on very fast updates
-    if interval_seconds < 0.05:
-        interval_seconds = 0.05
+    # use perf counter for more precision
+    now = time.perf_counter()
+    if _last_snapshot_time is None:
+        interval = 0.1 # Default for first run
+    else:
+        interval = now - _last_snapshot_time
+    _last_snapshot_time = now
 
     # Track which pids we see in this snapshot to evict dead ones later
     seen_pids = set()
 
     for proc in curr_snapshot:
         pid = proc["pid"]
         seen_pids.add(pid)
-
         prev = prev_cache.get(pid)
 
         total_time_now = proc["user_time_100ns"] + proc["kernel_time_100ns"]
 
         if prev:
             total_time_prev = prev["user_time_100ns"] + prev["kernel_time_100ns"]
             dt_100ns = max(0, total_time_now - total_time_prev)
-
-            # convert 100ns units to seconds
             dt_seconds = dt_100ns / 10_000_000.0
-
-            cpu = (dt_seconds / interval_seconds) * 100 / max(1, cpu_count)
+            
+            # Raw calculation
+            raw_cpu = (dt_seconds / interval) * 100 / max(1, cpu_count)
+            raw_cpu = max(0.0, min(raw_cpu, 100.0))
+            
+            # Apply EMA Smoothing: (New * Alpha) + (Old * (1 - Alpha))
+            prev_smooth = _ema_cache.get(pid, raw_cpu)
+            smooth_cpu = (raw_cpu * smoothing_factor) + (prev_smooth * (1.0 - smoothing_factor))
+            _ema_cache[pid] = smooth_cpu
         else:
-            cpu = 0.0
-
-        cpu = max(0.0, min(cpu, 100.0))
+            smooth_cpu = 0.0
+            _ema_cache[pid] = 0.0
 
         results.append({
             "pid": pid,
             "ppid": proc["ppid"],
             "name": proc["name"],
             "threads": proc["threads"],
-            "cpu_percent": cpu,
+            "cpu_percent": round(smooth_cpu, 2), # Rounding helps UI jitter
             "rss_bytes": proc["rss_bytes"],
         })
-
-        # Update cache in-place
+        # Update in-place
         prev_cache[pid] = proc
 
-    # Evict dead pids
-    # We do this by checking keys in prev_cache that are NOT in seen_pids
-    dead_pids = [pid for pid in prev_cache if pid not in seen_pids]
-    for pid in dead_pids:
-        del prev_cache[pid]
+    # Evict dead pids from cache
+    # did you know: i hate the eviction notice from tf2
+    dead_pids = [p for p in prev_cache if p not in seen_pids]
+    for p in dead_pids:
+        del prev_cache[p]
+        if p in _ema_cache: del _ema_cache[p]
 
     return results

modules/processes.py

@@ -4,38 +4,134 @@
 from .config import *
 from .utils import get_terminal_size, draw_bar, format_bytes
 
+# Startup splash messages
+STARTUP_MESSAGES = [
+    "Initializing terminal magic...",
+    "Poking the system kernel...",
+    "Interrogating your CPU...",
+    "Snooping on your storage...",
+    "Waking up the GPU...",
+    "Collecting process breadcrumbs...",
+    "Priming the performance counters...",
+    "Polishing the UI...",
+    "Reordering electrons...",
+    "Compiling bitstreams...",
+    "Calibrating flux capacitor...",
+    "Reticulating splines...",
+]
+
+def render_startup(step: int, total_steps: int, message: str = None):
+    """Render a startup splash screen with progress.
+    
+    Args:
+        step: Current step number (0-indexed)
+        total_steps: Total number of steps
+        message: Optional custom message, otherwise uses STARTUP_MESSAGES
+    """
+    cols, rows, _ = get_terminal_size()
+    
+    # Calculate progress
+    progress = min(100, int((step / max(1, total_steps)) * 100))
+    
+    # Get message
+    if message is None:
+        msg_idx = min(step, len(STARTUP_MESSAGES) - 1)
+        message = STARTUP_MESSAGES[msg_idx]
+    
+    # ASCII art logo
+    # cant we use literals so this doesnt look like shit?
+    logo = [
+        "   __    __        _____  ___  ___ ",
+        "  / / /\\ \\ \\/\\  /\\/__   \\/___\\/ _ \\",
+        "  \\ \\/  \\/ / /_/ /  / /\\//  // /_)/",
+        "   \\  /\\  / __  /  / / / \\_// ___/ ",
+        "    \\/  \\/\\/ /_/   \\/  \\___/\\/     ",
+    ]
+    
+    # We built this buffer on line by line (Heyo!)
+    lines = []
+    
+    # Vertical centering
+    content_height = len(logo) + 6
+    start_row = max(0, (rows - content_height) // 2)
+    
+    # Fill top padding
+    for _ in range(start_row):
+        lines.append("\033[K") # Empty line
+        
+    # Draw Logo
+    for line in logo:
+        padding = max(0, (cols - len(line)) // 2)
+        lines.append(f"{' ' * padding}{C_CYAN}{C_BOLD}{line}{C_RESET}\033[K")
+        
+    lines.append("\033[K")
+    lines.append("\033[K")
+    
+    # Draw Progress Bar
+    bar_width = min(50, cols - 20)
+    filled = int((progress / 100) * bar_width)
+    empty = bar_width - filled
+    
+    bar_str = f"{C_GREEN}{'█' * filled}{C_DIM}{'░' * empty}{C_RESET}"
+    progress_text = f"  [{bar_str}] {C_BOLD}{progress:3d}%{C_RESET}"
+    
+    # Center progress bar
+    # Text length approx bar_width + 12 chars invisible chars don't count for padding calculation but needed for total len
+    # We visually center based on visible width ~ bar_width + 8
+    pad_len = max(0, (cols - (bar_width + 8)) // 2)
+    lines.append(f"{' ' * pad_len}{progress_text}\033[K")
+    
+    lines.append("\033[K")
+    
+    # Draw Message
+    msg_len = len(message)
+    msg_pad = max(0, (cols - msg_len) // 2)
+    lines.append(f"{' ' * msg_pad}{C_YELLOW}{message}{C_RESET}\033[K")
+    
+    # Fill rest of screen
+    sys.stdout.write("\033[H") # Home
+    
+    # Output limited to rows to avoid scroll
+    # We need to construct string carefully
+    final_output = "\n".join(lines)
+    sys.stdout.write(final_output)
+    
+    # Clear rest of screen below content
+    sys.stdout.write("\033[J")
+    sys.stdout.flush()
+
 def render():
     """Render the entire UI."""
-    cols, rows = get_terminal_size()
+    cols, rows, toosmall = get_terminal_size()
 
     # Detect terminal resize
     if (cols, rows) != state.prev_term_size:
         sys.stdout.write("\033[2J")
         state.prev_term_size = (cols, rows)
 
-    # Validation for extremely small windows to prevent crash
-    if cols < 79 or rows < 18:
-        return
-    
     # We build the buffer line by line.
     lines = []
 
-    # --- Helper to add a line with safe ANSI handling ---
+    # Detect if the terminal is too small and write to status message
+    if toosmall:
+        state.status_message = "Window too small!"
+
+    # Helper to add a line with safe ANSI handling
     def add_line(text, bg_color=None):
         if bg_color:
             lines.append(f"{bg_color}{text}{C_RESET}\033[K")
         else:
             lines.append(f"{text}{C_RESET}\033[K")
 
-    # --- Header: Hardware Info ---
+    # Header: Hardware Info
     gpu_name_short = state.sys_stats['gpu_name'][:25] if state.sys_stats['gpu_available'] else "No GPU"
     cpu_name_short = state.sys_stats['cpu_name'][:35]
 
     header_content = f" CPU: {cpu_name_short}  |  GPU: {gpu_name_short} "
     padding_len = max(0, cols - len(header_content)) # approx check
     lines.append(f"{C_BG_HEADER}{C_BOLD}{header_content}{' ' * padding_len}{C_RESET}")
 
-    # --- Command Bar ---
+    # Command Bar
     speed_indicator = f"[{state.current_refresh_rate}]"
     cmd_display = f" > {state.input_buffer}"
     vis_len = len(cmd_display) + len(speed_indicator) + 1 
@@ -45,7 +141,7 @@ def add_line(text, bg_color=None):
 
     lines.append(f"{C_DIM}{'─' * cols}{C_RESET}\033[K")
 
-    # --- System Monitor ---
+    # System Monitor
     # Reserve header(3), footer(header+status+sep=3), min_proc(1) -> 7 lines reserved.
     max_sys_mon_lines = max(1, rows - 7)
     sys_mon_lines = []

modules/processsn.py

@@ -6,9 +6,12 @@ def get_terminal_size():
     """Get terminal dimensions."""
     try:
         size = os.get_terminal_size()
-        return size.columns, size.lines
+        if size.columns < 79 or size.lines < 18:
+            return size.columns, size.lines, True
+        else:
+            return size.columns, size.lines, False
     except:
-        return 100, 30
+        return 100, 30, False
 
 def draw_bar(percent, width=20, color=C_GREEN, empty_char="░", fill_char="█"):
     """Draw a colored progress bar."""