Upload 5 files

build.py

@@ -0,0 +1,49 @@
+import PyInstaller.__main__
+import shutil
+import os
+
+# Aufräumen vorheriger Builds
+for folder in ['build', 'dist', '__pycache__']:
+    if os.path.exists(folder):
+        shutil.rmtree(folder)
+
+# PyInstaller Optionen ohne --icon
+opts = [
+    'main.py',
+    '--name=SmartTaskTool_by_Sevenof9',
+    '--onefile',
+    #'--console',
+    '--noconsole',
+    '--windowed',
+    '--clean',
+    '--log-level=WARN',
+    '--add-data=gui.py;.',  # gui.py in dist/ kopieren
+    '--add-data=tray.py;.',  # tray.py in dist/ kopieren
+    '--add-data=hardware.py;.',  # hardware.py in dist/ kopieren
+    '--add-data=restart_helper.py;.',  # restart_helper.py in dist/ kopieren
+    '--add-data=DePixelSchmal.otf;.',
+]
+
+# Hidden-Imports
+hidden_imports = [
+    'win32com',
+    'win32com.client',
+    'pythoncom',
+    'pystray._win32',
+    'pystray._base',
+    'wmi',
+    'pynvml',
+    'pystray',
+    'PIL.Image',
+    'PIL.ImageDraw',
+    'PIL.ImageFont',
+    'pythoncom',
+    'wx',
+    'difflib',
+    'psutil'
+]
+
+for hidden in hidden_imports:
+    opts.append(f'--hidden-import={hidden}')
+
+PyInstaller.__main__.run(opts)

gui.py

@@ -0,0 +1,283 @@
+# gui.py
+
+import wx
+
+class MainFrame(wx.Frame):
+
+    MAX_WIDTH = 1000
+    MAX_HEIGHT = 1000
+    MIN_WIDTH = 300
+    MIN_HEIGHT = 200
+
+    def __init__(self, *args, hardware_info=None, result_queue=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.hardware_info = hardware_info or {}
+        self.result_queue = result_queue
+
+        self.selected_components = {
+            'cpu': True,
+            'ram': True,
+            'gpu': True,
+            'network': True,
+            'drives': []
+        }
+
+        # EVT_CLOSE binden
+        self.Bind(wx.EVT_CLOSE, self.on_close)
+
+        # Checkboxen speichern: Dictionary mit Kategorie als Key und Liste von Checkboxes als Value
+        self.checkboxes = {}
+
+        self.panel = wx.Panel(self)
+        vbox = wx.BoxSizer(wx.VERTICAL)
+
+        info = wx.StaticText(self.panel, label="Window will self-close in 10 sec")
+        vbox.Add(info, 0, wx.ALL, 10)
+
+        auto_close_info = wx.StaticText(
+            self.panel,
+            label="Drive monitoring (read/write) every second\nThreshold 2MB"
+        )
+        vbox.Add(auto_close_info, 0, wx.LEFT | wx.BOTTOM, 10)
+
+        tray_info = wx.StaticText(
+            self.panel,
+            label="(Hover over tray icon to see further information)"
+        )
+        vbox.Add(tray_info, 0, wx.LEFT | wx.BOTTOM, 10)
+
+        # CPU-Info: eine Checkbox mit zusammengesetzten Infos
+        if hardware_info.get('cpu_info'):
+            cpu_info = hardware_info['cpu_info']
+            cpu_label = (f"CPU Info: Logical cores: {cpu_info.get('logical_cores')}, "
+                         f"Physical cores: {cpu_info.get('physical_cores')}, "
+                         f"Frequency: {cpu_info.get('frequency', 'N/A')} MHz")
+            checkbox = wx.CheckBox(self.panel, label=cpu_label)
+            checkbox.SetValue(True)
+            vbox.Add(checkbox, 0, wx.LEFT | wx.BOTTOM, 10)
+            self.checkboxes['cpu'] = [checkbox]
+
+        # RAM-Info: eine Checkbox mit zusammengesetzten Infos
+        if hardware_info.get('ram_info'):
+            ram_info = hardware_info['ram_info']
+            ram_label = (f"RAM Info: Total: {ram_info.get('total_gb', 'N/A')} GB, "
+                         f"Available: {ram_info.get('available_gb', 'N/A')} GB")
+            checkbox = wx.CheckBox(self.panel, label=ram_label)
+            checkbox.SetValue(True)
+            vbox.Add(checkbox, 0, wx.LEFT | wx.BOTTOM, 10)
+            self.checkboxes['ram'] = [checkbox]
+
+        # GPU-Info
+        if hardware_info.get('gpu_info'):
+            self.add_section(vbox, "GPU Info:", [
+                f"{gpu['name']} ({gpu['memory_total_mb']} MB VRAM / MaxTemp: {gpu['max_temp']} °C)"
+                for gpu in hardware_info['gpu_info']
+            ], category="gpu")
+
+        # Netzwerkadapter
+        if hardware_info.get('network_adapters'):
+            self.add_section(vbox, "Active Network Adapters:", hardware_info['network_adapters'], category="network")
+
+        # Drive-Info
+        if hardware_info.get('drive_map'):
+            self.add_drive_section(vbox)
+
+        # Submit Button
+        self.submit_button = wx.Button(self.panel, label="Submit and Close (10)")
+        self.submit_button.Bind(wx.EVT_BUTTON, self.on_submit)
+        vbox.Add(self.submit_button, 0, wx.ALL | wx.CENTER, 10)
+
+        self.panel.SetSizer(vbox)
+        self.panel.Layout()
+        self.submit_button.SetFocus()
+        self.SetDefaultItem(self.submit_button)
+
+        best_size = self.panel.GetBestSize()
+        width = min(max(best_size.width, self.MIN_WIDTH), self.MAX_WIDTH)
+        height = min(max(best_size.height, self.MIN_HEIGHT), self.MAX_HEIGHT)
+        self.SetClientSize((width, height))
+        self.SetPosition((200,100))
+        self.SetTitle("SmartTaskTool by Sevenof9")
+
+        self.countdown_timer = 10
+        self.timer = wx.Timer(self)
+        self.Bind(wx.EVT_TIMER, self.update_countdown, self.timer)
+        self.timer.Start(1000)  # Update every second
+
+    def update_countdown(self, event):
+        self.countdown_timer -= 1
+        if self.countdown_timer <= 0:
+            self.submit_values()
+            self.timer.Stop()
+        else:
+            self.submit_button.SetLabel(f"Submit and Close ({self.countdown_timer})")
+
+    def add_drive_section(self, vbox):
+        drive_map = self.hardware_info.get('drive_map', {})
+        vbox.Add(wx.StaticText(self.panel, label="Detected Drives:"), 0, wx.LEFT | wx.TOP, 10)
+        for dev in sorted(drive_map.keys()):
+            parts = drive_map[dev]
+            for part_info in sorted(parts, key=lambda x: x['letter']):
+                letter = part_info.get('letter', 'N/A')
+                label = part_info.get('label', 'N/A')
+                checkbox_label = f"{dev} - {letter} ({label})"
+                checkbox = wx.CheckBox(self.panel, label=checkbox_label)
+                checkbox.SetValue(True)
+                vbox.Add(checkbox, 0, wx.LEFT | wx.BOTTOM, 10)
+
+                if 'drives' not in self.checkboxes:
+                    self.checkboxes['drives'] = []
+                self.checkboxes['drives'].append((dev, letter, checkbox))
+
+    def submit_values(self):
+        selected_components = {
+            'cpu': False,
+            'ram': False,
+            'gpu': False,
+            'network': False,
+            'drives': []
+        }
+
+        checkbox_categories = ['cpu', 'ram', 'gpu', 'network']
+        for category in checkbox_categories:
+            if category in self.checkboxes:
+                selected_components[category] = any(checkbox.GetValue() for checkbox in self.checkboxes[category])
+
+        if 'drives' in self.checkboxes:
+            for dev, part, checkbox in self.checkboxes['drives']:
+                if checkbox.GetValue():
+                    selected_components['drives'].append((dev, part))
+
+        # Hardwareinfo ergänzen
+        selected_components['cpu_info'] = self.hardware_info.get('cpu_info', {})
+        selected_components['ram_info'] = self.hardware_info.get('ram_info', {})
+        selected_components['gpu_info'] = self.hardware_info.get('gpu_info', [])
+        selected_components['network_adapters'] = self.hardware_info.get('network_adapters', [])
+        selected_components['drive_map'] = self.hardware_info.get('drive_map', {})
+
+        print("[DEBUG] Auswahl:", selected_components)
+        if self.result_queue:
+            self.result_queue.put(selected_components)
+        self.Close()
+
+    def on_submit(self, event):
+        print("[DEBUG] Submit-Button geklickt")
+        self.submit_values()
+
+    def add_section(self, vbox, title, items, category):
+        vbox.Add(wx.StaticText(self.panel, label=title), 0, wx.LEFT | wx.TOP, 10)
+        for item in items:
+            checkbox = wx.CheckBox(self.panel, label=item)
+            checkbox.SetValue(True)
+            vbox.Add(checkbox, 0, wx.LEFT | wx.BOTTOM, 10)
+
+            if category not in self.checkboxes:
+                self.checkboxes[category] = []
+
+            if category == "drives":
+                # Assuming dev and part are extracted from item
+                parts = item.split(":")
+                if len(parts) == 2:
+                    dev, part = parts
+                    self.checkboxes[category].append((dev.strip(), part.strip(), checkbox))
+            else:
+                self.checkboxes[category].append(checkbox)
+
+    def get_selected_components(self):
+        selected = {
+            'cpu': False,
+            'ram': False,
+            'gpu': False,
+            'network': False,
+            'drives': []
+        }
+
+        for category, checkboxes in self.checkboxes.items():
+            if category == 'drives':
+                # drives ist eine Liste von Tupeln: (dev, part, checkbox)
+                drive_map = self.hardware_info.get('drive_map', {})
+                selected_drives = []
+                for entry in self.checkboxes:
+                    if len(entry) == 3:
+                        category, checkbox, item = entry
+                        if category == "drives" and checkbox.GetValue():
+                            if ":" in item:
+                                dev, part = item.split(":", 1)
+                                selected_drives.append((dev.strip(), part.strip()))
+
+                selected['drives'] = selected_drives
+            else:
+                # normale checkbox listen
+                if any(checkbox.GetValue() for checkbox in checkboxes):
+                    selected[category] = True
+
+        # Hardwareinfos ergänzen
+        selected['cpu_info'] = self.hardware_info.get('cpu_info', {})
+        selected['ram_info'] = self.hardware_info.get('ram_info', {})
+        selected['gpu_info'] = self.hardware_info.get('gpu_info', [])
+        selected['network_adapters'] = self.hardware_info.get('network_adapters', [])
+        selected_components['drive_map'] = self.hardware_info.get('drive_map', {})
+
+        return selected
+
+    def on_close(self, event):
+        print("[DEBUG] Fenster wird geschlossen")
+
+        if hasattr(self, 'timer') and self.timer.IsRunning():
+            self.timer.Stop()
+
+        if self.result_queue:
+            # Leere Auswahl übermitteln
+            selected_components = {
+                'cpu': False,
+                'ram': False,
+                'gpu': False,
+                'network': False,
+                'drives': [],
+                'cpu_info': self.hardware_info.get('cpu_info', {}),
+                'ram_info': self.hardware_info.get('ram_info', {}),
+                'gpu_info': self.hardware_info.get('gpu_info', []),
+                'network_adapters': self.hardware_info.get('network_adapters', []),
+                'drive_map': self.hardware_info.get('drive_map', {})
+            }
+            self.result_queue.put(selected_components)
+
+        self.Destroy()
+
+        app = wx.GetApp()
+        if app:
+            app.ExitMainLoop()
+
+
+
+
+
+if __name__ == "__main__":
+    app = wx.App(False)
+
+    # Layout
+    hardware_info = {
+        'cpu_info': {
+            'logical_cores': 8,
+            'physical_cores': 4,
+            'frequency': 3200,
+        },
+        'ram_info': {
+            'total_gb': 16,
+            'available_gb': 10
+        },
+        'gpu_info': [
+            {'name': 'NVIDIA GTX 1080', 'memory_total_mb': 8192, 'max_temp': 84}
+        ],
+        'network_adapters': ['Ethernet', 'Wi-Fi'],
+        'drive_map': {
+            'Disk0': [{'letter': 'C:', 'label': 'System'}, {'letter': 'D:', 'label': 'Recovery'}],
+            'Disk1': [{'letter': 'E:', 'label': 'Data'}]
+        }
+
+
+    }
+
+    frame = MainFrame(None, hardware_info=hardware_info)
+    frame.Show()
+    app.MainLoop()

hardware.py

@@ -0,0 +1,142 @@
+# hardware.py
+import psutil
+import wmi
+import pynvml
+import threading
+import time
+
+
+def safe_call(func, name):
+    try:
+        return func()
+    except Exception as e:
+        print(f"[WARN] {name} konnte nicht geladen werden: {e}")
+        return None
+
+
+def get_physical_drives_with_partitions_and_labels():
+    c = wmi.WMI()
+    drive_map = {}
+
+    for disk in c.Win32_DiskDrive():
+        disk_id = disk.DeviceID.split("\\")[-1].upper()
+        if disk_id not in drive_map:
+            drive_map[disk_id] = []
+
+        partitions = disk.associators("Win32_DiskDriveToDiskPartition")
+        for partition in partitions:
+            logical_disks = partition.associators("Win32_LogicalDiskToPartition")
+            for logical_disk in logical_disks:
+                letter = logical_disk.DeviceID.upper().strip()
+                volume_name = logical_disk.VolumeName or "Kein Name"
+                if not any(d["letter"] == letter for d in drive_map[disk_id]):
+                    drive_map[disk_id].append({
+                        "letter": letter,
+                        "label": volume_name
+                    })
+    print("[DEBUG] Drive Info:", drive_map)
+    return drive_map
+
+
+
+def get_cpu_info():
+    cpu_freq = psutil.cpu_freq()
+    cpu_info = {
+        "logical_cores": psutil.cpu_count(logical=True),
+        "physical_cores": psutil.cpu_count(logical=False),
+        "frequency": round(cpu_freq.max) if cpu_freq else None,
+    }
+    return cpu_info
+
+
+def get_ram_info():
+    mem = psutil.virtual_memory()
+    ram_info = {
+        "total_gb": round(mem.total / (1024 ** 3)),
+        "available_gb": round(mem.available / (1024 ** 3)),
+    }
+    print("[DEBUG] RAM Info:", ram_info)
+    return ram_info
+
+
+
+def get_gpu_info():
+    gpu_info = []
+    pynvml.nvmlInit()
+    try:
+        device_count = pynvml.nvmlDeviceGetCount()
+        for i in range(device_count):
+            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
+            name_raw = pynvml.nvmlDeviceGetName(handle)
+            name = name_raw.decode() if isinstance(name_raw, bytes) else name_raw
+            mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
+
+            try:
+                max_temp = pynvml.nvmlDeviceGetTemperatureThreshold(
+                    handle,
+                    pynvml.NVML_TEMPERATURE_THRESHOLD_GPU_MAX
+                )
+            except Exception:
+                max_temp = 90
+
+            gpu_info.append({
+                "name": name,
+                "memory_total_mb": int(mem_info.total / 1024**2),
+                "max_temp": max_temp
+            })
+    except Exception as e:
+        print(f"[WARN] GPU-Info konnte nicht geladen werden: {e}")
+    finally:
+        pynvml.nvmlShutdown()
+    print("[DEBUG] RAM Info:", gpu_info)        
+    return gpu_info
+
+
+def get_network_adapters():
+    c = wmi.WMI()
+    adapters = []
+    for nic in c.Win32_NetworkAdapterConfiguration(IPEnabled=True):
+        if hasattr(nic, 'Description'):
+            adapters.append(nic.Description)
+    print("[DEBUG] RAM Info:", adapters)
+    return adapters
+
+
+def detect_hardware():
+    drive_map = safe_call(get_physical_drives_with_partitions_and_labels, "Laufwerke") or {}
+    cpu_info = safe_call(get_cpu_info, "CPU") or {}
+    gpu_info = safe_call(get_gpu_info, "GPU") or []
+    ram_info = safe_call(get_ram_info, "RAM") or {}
+    network_adapters = safe_call(get_network_adapters, "Netzwerkadapter") or []
+    '''
+    device_partitions = [
+        (dev, part)
+        for dev, parts in drive_map.items()
+        for part in parts
+    ]
+    '''
+    return {
+        'cpu_info': cpu_info,
+        'ram_info': ram_info,
+        'gpu_info': gpu_info,
+        'network_adapters': network_adapters,
+        'drive_map': drive_map
+    }
+
+
+
+def main():
+    print("[INFO] Starte Hardware-Erkennung...\n")
+    hardware_info = detect_hardware()
+
+    # Optional: Ausgabe der erkannten Hardware (kann auskommentiert werden)
+    #for key, value in hardware_info.items():
+    #    print(f"[RESULT] {key}: {value}")
+
+    print("\n[INFO] Warte 5 Sekunden...")
+    time.sleep(5)
+    print("[INFO] Hardware Erkennung beendet.")
+
+if __name__ == "__main__":
+    main()
+

main.py

@@ -0,0 +1,115 @@
+import wx
+import sys
+import threading
+import queue
+import time
+import os
+from gui import MainFrame
+from tray import start_tray_monitoring, shutdown_requested
+from hardware import detect_hardware
+
+# main.py
+
+def start_gui_and_get_selection(hardware_info, result_queue):
+    class App(wx.App):
+        def OnInit(self):
+            self.frame = MainFrame(None, hardware_info=hardware_info, result_queue=result_queue)
+            self.frame.Show()
+            return True
+
+    app = App(False)
+    app.MainLoop()
+
+
+def save_exe_dir_to_meipass():
+    try:
+        # Ermittlung des MEIPASS-Pfads (nur wenn als .exe via PyInstaller gestartet)
+        if hasattr(sys, '_MEIPASS'):
+            meipass_dir = sys._MEIPASS
+        else:
+            print("[WARN] Kein MEIPASS gefunden (nicht als EXE gestartet). Überspringe Speichern.")
+            return
+
+        # Pfad zur laufenden .exe
+        if getattr(sys, 'frozen', False):
+            #exe_dir = os.path.dirname(sys.executable)
+            exe_path = sys.executable  # <- vollständiger Pfad zur exe inkl. Dateiname
+        else:
+            #exe_dir = os.path.dirname(os.path.abspath(__file__))
+            exe_path = os.path.abspath(__file__)  # <- vollständiger Pfad zur .py Datei
+
+        # Zieldatei im MEIPASS-Verzeichnis
+        output_file = os.path.join(meipass_dir, "startdir.txt")
+
+        with open(output_file, "w", encoding="utf-8") as f:
+            #f.write(f"Startverzeichnis: {exe_dir}\n")
+            f.write(f"{exe_path}\n")
+
+        print(f"[INFO] Startverzeichnis und Startdatei gespeichert in MEIPASS: {output_file}")
+    except Exception as e:
+        print(f"[ERROR] Fehler beim Schreiben der startdir.txt: {e}")
+
+
+if __name__ == "__main__":
+    try:
+        time.sleep(0.5)
+
+        # Schreibe das Startverzeichnis in den MEIPASS-Ordner
+        save_exe_dir_to_meipass()
+
+        print("[DEBUG] Starte hardware.py...")
+        hardware_info = detect_hardware()
+        print("[DEBUG] hardware.py exit...")
+
+        result_queue = queue.Queue()
+
+        # GUI im MainThread starten!
+        start_gui_and_get_selection(hardware_info, result_queue)
+
+        print("[INFO] GUI beendet.")
+
+        try:
+            selected_components = result_queue.get(timeout=11)
+            tray_should_start = any([
+                selected_components.get('cpu'),
+                selected_components.get('ram'),
+                selected_components.get('gpu'),
+                selected_components.get('network'),
+                bool(selected_components.get('drives'))
+            ])
+        except queue.Empty:
+            print("[WARN] Keine Rückgabe durch GUI. Traymonitor wird nicht gestartet.")
+            tray_should_start = False
+
+        if tray_should_start:
+            print("[INFO] Auswahl empfangen:", selected_components)
+            time.sleep(1)
+
+            tray_thread = threading.Thread(
+                target=start_tray_monitoring,
+                args=(hardware_info, selected_components),
+                daemon=False
+            )
+            tray_thread.start()
+
+            # Haupt-Exit-Überwachung
+            while not shutdown_requested.wait(timeout=0.1):
+                pass
+
+            print("[INFO] Tray-Exit wurde erkannt – beende main.py.")
+            sys.exit(0)
+
+
+            print("[INFO] Tray-Monitoring gestartet. GUI ist geschlossen.")
+            tray_thread.join()
+        else:
+            print("[INFO] Programm wird beendet, da keine Auswahl getroffen wurde (GUI geschlossen).")
+            sys.exit(0)  # Sauber beenden, wenn kein Traymonitor starten soll
+
+    except KeyboardInterrupt:
+        print("[INFO] Manuell beendet.")
+        sys.exit(0)
+    except Exception as e:
+        print(f"[ERROR] Unerwarteter Fehler: {e}", file=sys.stderr)
+        sys.exit(1)
+

tray.py

@@ -0,0 +1,830 @@
+# tray.py
+import threading
+from threading import Event
+from pystray import Icon, MenuItem, Menu
+from PIL import Image, ImageDraw, ImageFont
+#from functools import partial
+import os
+import sys
+import time
+import psutil
+import pythoncom
+import wmi
+#import ctypes
+import pynvml
+from pynvml import *
+# from pynvml import nvmlDeviceGetTemperature, nvmlDeviceGetTemperatureThreshold, NVML_TEMPERATURE_GPU, NVML_TEMPERATURE_THRESHOLD_GPU_MAX, nvmlInit, nvmlShutdown, nvmlDeviceGetHandleByIndex, nvmlDeviceGetUtilizationRates, nvmlDeviceGetMemoryInfo, nvmlDeviceGetCount, nvmlDeviceGetName
+from difflib import get_close_matches
+import subprocess  # Importieren Sie subprocess
+import tempfile
+import shutil
+
+icons = {}
+current_colors = {}
+last_colors = {}
+stop_events = {}
+color_lock = threading.Lock()
+icon_lock = threading.Lock()
+
+
+COLOR_MAP = {
+    "gray": (160, 160, 160, 255),
+    "green": (0, 128, 0, 255),
+    "red": (128, 0, 0, 255),
+    "yellow": (220, 220, 0, 255)
+}
+
+
+def managed_thread(target, *args, **kwargs):
+    """
+    Führt target(*args, **kwargs) in Schleife aus, bis shutdown_event gesetzt ist.
+    Ideal für Monitoring-Loops.
+    """
+    def wrapper():
+        while not shutdown_event.is_set():
+            target(*args, **kwargs)
+            time.sleep(2.1)  # oder individuell einstellbar
+    t = threading.Thread(target=wrapper, daemon=True)
+    thread_refs.append(t)
+    t.start()
+
+shutdown_event = Event()
+thread_refs = []
+shutdown_requested = threading.Event() 
+
+
+def resource_path(relative_path):
+    try:
+        base_path = getattr(sys, '_MEIPASS', os.path.abspath(os.path.dirname(__file__)))
+        full_path = os.path.join(base_path, relative_path)
+        if not os.path.exists(full_path) and hasattr(sys, 'frozen'):
+            raise FileNotFoundError  # Trigger fallback
+        return full_path
+    except (AttributeError, FileNotFoundError):
+        try:
+            import pkgutil
+            data = pkgutil.get_data(__name__, relative_path)
+            if data:
+                temp_dir = tempfile.gettempdir()
+                temp_file = os.path.join(temp_dir, os.path.basename(relative_path))
+                with open(temp_file, 'wb') as f:
+                    f.write(data)
+                return temp_file
+        except Exception as e:
+            print(f"[ERROR] Fallback-Resource-Pfad fehlgeschlagen: {e}")
+
+    # Last resort: use relative path from package root
+    pkg_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "your_package_name"))
+    fallback_path = os.path.join(pkg_root, relative_path)
+    if os.path.exists(fallback_path):
+        return fallback_path
+
+    raise FileNotFoundError(f"Resource '{relative_path}' not found in any path.")
+
+
+font_path = resource_path("DePixelSchmal.otf")
+
+def round_to_nearest_five(value):
+    return int(round(value / 5.0) * 5)
+
+def get_active_network_adapters():
+    c = wmi.WMI()
+    adapters = []
+    for nic in c.Win32_NetworkAdapterConfiguration(IPEnabled=True):
+        if hasattr(nic, 'Description'):
+            adapters.append(nic.Description)
+    return adapters
+
+def get_adapter_speeds():
+    c = wmi.WMI()
+    speeds = {}
+    for nic in c.Win32_NetworkAdapter():
+        if nic.NetEnabled and nic.Speed:
+            speeds[nic.Name] = int(nic.Speed)  # Bits per second
+    return speeds
+
+def find_best_match(name, candidates):
+    matches = get_close_matches(name, candidates, n=1, cutoff=0.6)
+    return matches[0] if matches else None
+
+def create_text_icon(text, color=(255, 255, 255, 255), bg_color=(0, 0, 0, 0)):
+    size = 77
+    image = Image.new("RGBA", (size, size), bg_color)
+    draw = ImageDraw.Draw(image)
+
+    try:
+        font = ImageFont.truetype(font_path, 29)
+    except Exception:
+        font = ImageFont.load_default()
+
+    bbox = draw.textbbox((0, 0), text, font=font) if hasattr(draw, 'textbbox') else font.getsize(text)
+    text_w, text_h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    text_x = (size - text_w) // 2 - bbox[0]
+    text_y = (size - text_h) // 2 - bbox[1]
+
+    draw.text((text_x, text_y), text, font=font, fill=color)
+    return image
+
+def format_speed_custom(value_kb):
+    units = ['kB/s', 'MB/s', 'GB/s']
+    speed = value_kb
+    unit_index = 0
+
+    while speed >= 100 and unit_index < len(units) - 1:
+        speed /= 1024
+        unit_index += 1
+
+    if speed < 10:
+        display = f"{speed:.1f}"
+    else:
+        display = f"{min(round(speed), 99)}"
+
+    return f"{display}\n{units[unit_index]}"
+
+# drive icon
+def get_color(read_active, write_active, read_mb=0, write_mb=0):
+    if read_mb < 2 and write_mb < 2:
+        return "gray"
+    elif read_mb >= 2 and write_mb >= 2:
+        ratio = read_mb / write_mb if write_mb != 0 else float('inf')
+        if 1/5 <= ratio <= 5:
+            return "yellow"
+        elif write_mb > read_mb:
+            return "red"
+        else:
+            return "green"
+    elif write_mb >= 2:
+        return "red"
+    elif read_mb >= 2:
+        return "green"
+    return "gray"
+
+
+def _set_icon_color(key, color):
+    with icon_lock:
+        icon_data = icons.get(key)
+        if icon_data:
+            icon = icon_data["icon"]
+            label = icon_data["label"]
+            new_icon = create_icon(COLOR_MAP.get(color, (128, 128, 128)), label)
+            try:
+                icon.icon = new_icon
+            except Exception as e:
+                print(f"[WARN] Could not update icon for {key}: {e}")
+            finally:
+                with color_lock:
+                    last_colors[key] = color
+
+# Drive letter ICONS
+def create_icon(color_rgb, label):
+    size = 77
+    image = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+
+    draw.ellipse((0, 0, size, size), fill=color_rgb)
+
+    try:
+        font = ImageFont.truetype(font_path, 55)
+    except Exception:
+        font = ImageFont.load_default()
+
+    if hasattr(draw, 'textbbox'):
+        bbox = draw.textbbox((0, 0), label, font=font)
+    else:
+        width, height = font.getsize(label)
+        bbox = (0, 0, width, height)
+
+    text_w = bbox[2] - bbox[0]
+    text_h = bbox[3] - bbox[1]
+    text_x = (size - text_w) / 2
+    text_y = (size - text_h) / 2 - bbox[1]
+
+    brightness = sum(color_rgb) / 3
+    text_color = (0, 0, 0, 255) if brightness > 130 else (255, 255, 255, 255)
+
+    draw.text((text_x, text_y), label, font=font, fill=text_color)
+    return image
+    
+def update_tray_color(key, color):
+    with color_lock:
+        old_color = current_colors.get(key)
+        if old_color == color:
+            return
+        current_colors[key] = color
+
+
+
+def _icon_updater(key, stop_event):
+    while not stop_event.is_set():
+        with color_lock:
+            color = current_colors.get(key, "gray")
+            last_color = last_colors.get(key)
+
+        if color != last_color:
+            try:
+                _set_icon_color(key, color)
+            except Exception as e:
+                print(f"[WARN] Icon update failed for {key}: {e}")
+
+        stop_event.wait(0.2)
+
+
+
+# gradient color bar ICON: cpu, ram, gpu, vram, temp
+def get_gradient_color(percent):
+    """
+    Gibt eine Farbe für den gegebenen Prozentwert aus einem Regenbogenverlauf zurück:
+    0% -> grün, 50% -> gelb, 100% -> rot
+    """
+    if percent <= 50:
+        # Grün → Gelb
+        ratio = percent / 50.0
+        r = int(COLOR_MAP["green"][0] + ratio * (COLOR_MAP["yellow"][0] - COLOR_MAP["green"][0]))
+        g = int(COLOR_MAP["green"][1] + ratio * (COLOR_MAP["yellow"][1] - COLOR_MAP["green"][1]))
+        b = int(COLOR_MAP["green"][2] + ratio * (COLOR_MAP["yellow"][2] - COLOR_MAP["green"][2]))
+    else:
+        # Gelb → Rot
+        ratio = (percent - 50) / 50.0
+        r = int(COLOR_MAP["yellow"][0] + ratio * (COLOR_MAP["red"][0] - COLOR_MAP["yellow"][0]))
+        g = int(COLOR_MAP["yellow"][1] + ratio * (COLOR_MAP["red"][1] - COLOR_MAP["yellow"][1]))
+        b = int(COLOR_MAP["yellow"][2] + ratio * (COLOR_MAP["red"][2] - COLOR_MAP["yellow"][2]))
+
+    return (r, g, b, 255)
+
+
+def create_bar_icon(percent, label, color=None):
+    """
+    Erstellt ein Balken-Icon mit Regenbogen-Farbverlauf.
+    0% → unten grün, 50% → mitte gelb, 100% → oben rot
+    """
+    size = 77
+    margin = 4
+    image = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+
+    # Balkengröße
+    bar_width = size - 2 * margin
+    bar_height = int((percent / 100.0) * size)
+    bar_x0 = margin
+    bar_x1 = size - margin
+    bar_y_bottom = size - 1
+    bar_y_top = bar_y_bottom - bar_height + 1
+
+    # Farbverlauf zeichnen
+    for i in range(bar_height):
+        rel_percent = (i / bar_height) * percent
+        line_color = get_gradient_color(rel_percent)
+        y = bar_y_bottom - i
+        draw.line([(bar_x0, y), (bar_x1, y)], fill=line_color)
+
+    # Label zeichnen
+    try:
+        font = ImageFont.truetype(font_path, 30)
+    except:
+        font = ImageFont.load_default()
+
+    draw.text((2, 2), label, font=font, fill=(255, 255, 255, 255))
+
+    return image
+
+
+
+def _on_quit(icon_inst=None, item=None):
+    print("[INFO] Beenden eingeleitet...")
+
+    # 1. Stop-Flag setzen und Threads sauber beenden
+    shutdown_event.set()
+    for t in thread_refs:
+        t.join(timeout=2.1)
+    print("[INFO] Alle Threads beendet.")
+
+    # 2. Tray-Icons stoppen
+    stop_all_tray_icons()
+    print("[INFO] Alle Trays beendet.")
+    # 3. pynvml sauber beenden
+    try:
+        pynvml.nvmlShutdown()
+    except Exception:
+        pass
+    print("[INFO] Nvidia shut down.")    
+    time.sleep(0.1)
+    shutdown_requested.set()
+
+
+def _on_restart(icon_inst=None, item=None):
+    print("[INFO] Neustart eingeleitet...")
+
+    # 1. Stop-Flag setzen und Threads sauber beenden
+    shutdown_event.set()
+    for t in thread_refs:
+        t.join(timeout=2.1)
+    print("[INFO] Alle Threads beendet.")
+
+    # 2. Tray-Icons stoppen
+    stop_all_tray_icons()
+
+    # 3. pynvml sauber beenden
+    try:
+        pynvml.nvmlShutdown()
+    except Exception:
+        pass
+
+    time.sleep(0.1)
+
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    startdir_path = os.path.join(base_dir, "startdir.txt")
+    print("[INFO] Start Folder lesen")
+    try:
+        with open(startdir_path, "r", encoding="utf-8") as f:
+            executable_path = f.readline().strip()
+        if not os.path.isfile(executable_path):
+            raise FileNotFoundError(f"EXE nicht gefunden: {executable_path}")
+    except Exception as e:
+        print(f"[ERROR] Fehler beim Lesen der startdir.txt: {e}")
+        if icon_inst:
+            icon_inst.stop()
+        return
+
+    exe_dir = os.path.dirname(executable_path)
+    
+    time.sleep(0.1)
+    try:
+        print(f"[INFO] Starte EXE erneut (via subprocess.Popen): {executable_path}")
+
+        env = os.environ.copy()
+        env["RESTART_COUNT"] = str(int(env.get("RESTART_COUNT", "0")) + 1)
+        env["PYINSTALLER_RESET_ENVIRONMENT"] = "1" 
+
+        subprocess.Popen(
+            [executable_path],
+            cwd=exe_dir,
+            env=env,
+            close_fds=True,
+            shell=False
+        )
+
+        print(f"[INFO] EXE gestartet!")
+    except Exception as e:
+        print(f"[ERROR] Fehler beim Start via Popen: {e}")
+        return
+    print("[INFO] Old Instance EXIT")
+    time.sleep(0.5)
+    shutdown_requested.set()
+
+
+
+
+def stop_all_tray_icons():
+    for icon in icons.values():
+        try:
+            if icon["icon"].visible:
+                icon["icon"].visible = False
+                icon["icon"].stop()
+        except Exception as e:
+            print(f"[WARN] Icon-Stop fehlgeschlagen: {e}")
+    for event in stop_events.values():
+        event.set()
+
+def update_tray_tooltip(key, tooltip_text):
+    icon_data = icons.get(key)
+    if icon_data:
+        icon = icon_data["icon"]
+        try:
+            icon.title = tooltip_text[:127]
+        except Exception as e:
+            print(f"[WARN] Tooltip konnte nicht gesetzt werden für {key}: {e}")
+
+def update_net_icons(adapter_name, send_kb, recv_kb, selected_components):
+    menu = Menu(
+        MenuItem("Restart", lambda icon_inst, item: _on_restart(icon_inst, item)),
+        MenuItem("Exit", lambda icon_inst, item: _on_quit(icon_inst, item))
+    )
+
+
+    def update_icon(direction, value_kb):
+        if not selected_components['network']:
+            return
+
+        if value_kb < 10:
+            value_kb = 0
+
+        key = f"NET_{adapter_name}, Direction: {direction}"
+        text_with_linebreak = f"{'U ' if direction == 'SEND' else 'D '}{format_speed_custom(value_kb)}"
+        speed_parts = format_speed_custom(value_kb).split("\n")
+        text_no_linebreak = f"{speed_parts[0]} {speed_parts[1]}" if len(speed_parts) == 2 else format_speed_custom(value_kb)
+
+        image = create_text_icon(text_with_linebreak)
+        if key not in icons:
+            icon = Icon(key, image, menu=menu)
+            icons[key] = {"icon": icon, "label": key}
+            print(f"Created Network icon {key}")
+            icon.run_detached()
+        else:
+            icons[key]["icon"].icon = image
+            # Set tooltip using the update_tray_tooltip function
+            tooltip = f"{adapter_name} {'Upload' if direction == 'SEND' else 'Download'}: {text_no_linebreak}"
+            tooltip = tooltip[:127] # falls percpu=True (tooltips max128 zeichen)
+            update_tray_tooltip(key, tooltip)
+
+    threading.Thread(target=update_icon, args=("SEND", send_kb), daemon=True).start()
+    threading.Thread(target=update_icon, args=("RECV", recv_kb), daemon=True).start()
+
+
+def sort_selected_drives(drive_selections, device_map):
+    items = [(dev, part) for dev, parts in device_map.items() for part in parts]
+    
+    # Zugriff auf 'letter' für Sortierung
+    sorted_items = sorted(items, key=lambda x: x[1]['letter'].upper(), reverse=True)
+    
+    # Auch drive_selections sortieren anhand des zweiten Elements (Laufwerksbuchstabe)
+    return sorted(drive_selections, key=lambda x: x[1].upper(), reverse=True)
+
+
+def start_drive_icons(hardware_info, stop_all_tray_icons, device_map, drive_selections):
+    print("Starting tray icons for selected drives...")
+    menu = Menu(
+        MenuItem("Restart", lambda icon_inst, item: _on_restart(icon_inst, item)),
+        MenuItem("Exit", lambda icon_inst, item: _on_quit(icon_inst, item))
+    )
+
+
+    sorted_drive_selections = sort_selected_drives(drive_selections, device_map)
+
+    for index, (dev, part) in enumerate(sorted_drive_selections):
+        icon_label = part.strip(":")
+        icon_key = f"{dev}_{part}"
+        icon_title = f"{index}_SmartTaskTool_{icon_label}"
+
+        image = create_icon(COLOR_MAP["gray"], icon_label)
+        icon = Icon(icon_title, image, menu=menu)
+        icons[icon_key] = {"icon": icon, "label": icon_label}
+        current_colors[icon_key] = "gray"
+        last_colors[icon_key] = None
+        stop_event = threading.Event()
+        stop_events[icon_key] = stop_event
+
+        icon.run_detached()
+
+        threading.Thread(target=_icon_updater, args=(icon_key, stop_event), daemon=True).start()
+        time.sleep(0.2)
+
+    print("Started Icons:")
+    for key, value in icons.items():
+        print(f"  {key}: {value}")
+
+
+def start_tray_monitoring(hardware_info, selected_components):
+    if not isinstance(selected_components, dict):
+        raise ValueError("selected_components muss ein Dictionary sein")
+
+    expected_keys = ['cpu', 'ram', 'gpu', 'network', 'drives']
+
+    # Check if all expected keys are present and have the correct type
+    for key in expected_keys:
+        if key not in selected_components:
+            raise KeyError(f"selected_components fehlt: '{key}'")
+        
+        value = selected_components[key]
+
+        if key == 'drives':
+            if not isinstance(value, list):
+                raise TypeError(f"'{key}' muss eine Liste sein.")
+            if not all(isinstance(item, tuple) and len(item) == 2 for item in value):
+                raise ValueError(f"Jedes Element in '{key}' muss ein Tuple mit zwei Elementen sein.")
+        else:
+            if not isinstance(value, bool):
+                raise TypeError(f"'{key}' muss ein Boolean sein.")
+
+    print("Starting tray monitoring...")
+
+    menu = Menu(
+        MenuItem("Restart", lambda icon_inst, item: _on_restart(icon_inst, item)),
+        MenuItem("Exit", lambda icon_inst, item: _on_quit(icon_inst, item))
+    )
+
+    def update_cpu(percent):  # Dummy-Wert, tatsächliche Auswertung erfolgt kontrolliert
+        if not selected_components['cpu']:
+            return
+
+        # CPU-Werte kontrolliert ermitteln
+        try:
+            logical = psutil.cpu_count(logical=True)
+            physical = psutil.cpu_count(logical=False)
+            cpu_percentages = psutil.cpu_percent(interval=None, percpu=True)
+
+            num_cores = logical if logical else physical
+            core_usages = cpu_percentages[:num_cores]
+
+            if not core_usages:
+                raise ValueError("Keine CPU-Werte erhalten.")
+
+            avg_cpu_percent = sum(core_usages) / len(core_usages)
+            percent = round_to_nearest_five(avg_cpu_percent)
+        except Exception as e:
+            print(f"[ERROR] CPU-Auswertung fehlgeschlagen: {e}")
+            percent = 0
+            core_usages = []
+            num_cores = 0
+
+        # Icon-Update
+        image = create_bar_icon(percent, "CPU")
+        key = "CPU_USAGE"
+        if key not in icons:
+            icon = Icon(key, image, menu=menu)
+            icons[key] = {"icon": icon, "label": "CPU"}
+            print(f"Created CPU icon")
+            threading.Thread(target=icon.run, daemon=True).start()
+        else:
+            icons[key]["icon"].icon = image
+
+        # Tooltip
+        try:
+            cores_str = " | ".join([f"{int(p)}%" for p in core_usages])
+            tooltip = f"{num_cores} Cores: {cores_str}"
+            tooltip = tooltip[:127]
+            update_tray_tooltip(key, tooltip)
+        except Exception:
+            tooltip = f"CPU {percent}%"
+
+        #icons[key]["icon"].title = tooltip
+
+
+    def update_ram(percent):
+        if not selected_components['ram']:
+            return
+        percent = round_to_nearest_five(percent)
+        image = create_bar_icon(percent, "RAM")
+        key = "RAM_USAGE"
+        if key not in icons:
+            icon = Icon(key, image, menu=menu)
+            icons[key] = {"icon": icon, "label": "RAM"}
+            print(f"Created RAM icon")
+            threading.Thread(target=icon.run, daemon=True).start()
+        else:
+            icons[key]["icon"].icon = image
+
+        try:
+            mem = psutil.virtual_memory()
+            used_gb = round(mem.used / (1024 ** 3))
+            total_gb = round(mem.total / (1024 ** 3))
+            tooltip = f"RAM {used_gb} / {total_gb} GB"
+            update_tray_tooltip(key, tooltip)
+        except Exception:
+            tooltip = f"RAM: {percent}%"
+        #icons[key]["icon"].title = tooltip
+
+
+    def update_gpu_vram_temp(idx, util, mem_used, mem_total, temp, max_temp):
+        if not selected_components['gpu']:
+            return
+
+        # === Temperatur ===
+        key_temp = f"GPU{idx}_TEMP"
+        label_temp = f"T{idx}"
+        temp_rounded = round(temp)
+        # Temperatur in Prozent (dynamisch zu max_temp)
+        clamped = max(35, min(temp, max_temp))  # untere Grenze: 35°C
+        pct = round((clamped - 35) / (max_temp - 35) * 100)
+        image_temp = create_bar_icon(pct, label_temp)
+        
+        if key_temp not in icons:
+            try:
+                icon = Icon(key_temp, image_temp, menu=menu)
+                icons[key_temp] = {"icon": icon, "label": label_temp}
+                print(f"Created GPU{idx} temperature icon.")
+                threading.Thread(target=icon.run, daemon=True).start()
+            except Exception as e:
+                print(f"Error creating GPU{idx} temperature icon: {e}")
+        else:
+            icons[key_temp]["icon"].icon = image_temp
+
+
+        tooltip = f"{label_temp}: {temp_rounded} °C / {max_temp} °C"
+        tooltip = tooltip[:127]
+        update_tray_tooltip(key_temp, tooltip)
+        #icons[key_temp]["icon"].title = f"{label_temp}: {temp_rounded} °C / {max_temp} °C"
+        time.sleep(0.01)
+
+
+        # === VRAM-Nutzung ===
+        key_vram = f"VRAM{idx}_USAGE"
+        label_vram = f"VR{idx}"
+        vram_util = round_to_nearest_five(mem_used / mem_total * 100)
+        image_vram = create_bar_icon(vram_util, label_vram)
+
+        if key_vram not in icons:
+            try:
+                icon = Icon(key_vram, image_vram, menu=menu)
+                icons[key_vram] = {"icon": icon, "label": label_vram}
+                print(f"Created VRAM{idx} usage icon.")
+                threading.Thread(target=icon.run, daemon=True).start()
+            except Exception as e:
+                print(f"Error creating VRAM{idx} usage icon: {e}")
+        else:
+            icons[key_vram]["icon"].icon = image_vram
+
+        used_gb = round(mem_used / (1024**3))
+        total_gb = round(mem_total / (1024**3))
+        # Set tooltip using the update_tray_tooltip function
+        tooltip = f"{label_vram}: {used_gb}/{total_gb} GB"
+        tooltip = tooltip[:127]
+        update_tray_tooltip(key_vram, tooltip)
+
+        #icons[key_vram]["icon"].title = f"{label_vram}: {used_gb}/{total_gb} GB"
+        time.sleep(0.01)
+
+
+        # === GPU-Nutzung ===
+        key_gpu = f"GPU{idx}_USAGE"
+        label_gpu = f"GPU{idx}"
+        image_gpu = create_bar_icon(util, label_gpu)
+
+        if key_gpu not in icons:
+            try:
+                icon = Icon(key_gpu, image_gpu, menu=menu)
+                icons[key_gpu] = {"icon": icon, "label": label_gpu}
+                print(f"Created GPU{idx} usage icon.")
+                threading.Thread(target=icon.run, daemon=True).start()
+            except Exception as e:
+                print(f"Error creating GPU{idx} usage icon: {e}")
+        else:
+            icons[key_gpu]["icon"].icon = image_gpu
+            #icons[key_gpu]["icon"].title = f"{label_gpu}: {util}%"
+
+       # Set tooltip using the update_tray_tooltip function
+        tooltip = f"{label_gpu}: {util}%"
+        tooltip = tooltip[:127]
+        update_tray_tooltip(key_gpu, tooltip)
+
+
+    def gpu_monitor():
+        try:
+            pynvml.nvmlInit()
+            gpu_data = []
+
+            for idx in range(pynvml.nvmlDeviceGetCount()):
+                handle = pynvml.nvmlDeviceGetHandleByIndex(idx)
+                try:
+                    max_temp = pynvml.nvmlDeviceGetTemperatureThreshold(
+                        handle, pynvml.NVML_TEMPERATURE_THRESHOLD_GPU_MAX
+                    )
+                except pynvml.NVMLError:
+                    max_temp = 90  # Fallback
+
+                gpu_data.append((idx, handle, max_temp))
+
+            while not shutdown_event.is_set():
+            #while True:
+                for idx, handle, max_temp in gpu_data:
+                    try:
+                        util = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
+                        mem = pynvml.nvmlDeviceGetMemoryInfo(handle)
+                        temp = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
+
+                        update_gpu_vram_temp(idx, util, mem.used, mem.total, temp, max_temp)
+
+                    except pynvml.NVMLError as e:
+                        print(f"[ERROR] GPU{idx} Fehler: {e}")
+
+                time.sleep(0.5)
+
+        except pynvml.NVMLError as e:
+            print(f"[ERROR] NVML Initialisierung fehlgeschlagen: {e}")
+
+
+
+    def cpu_monitor():
+        while not shutdown_event.is_set():
+            try:
+                update_cpu(psutil.cpu_percent(interval=None))
+            except Exception as e:
+                print(f"[ERROR] CPU Monitoring Fehler: {e}")
+            time.sleep(0.5)
+
+    def ram_monitor():
+        while not shutdown_event.is_set():
+            try:
+                mem = psutil.virtual_memory()
+                update_ram(mem.percent)
+            except Exception as e:
+                print(f"[ERROR] RAM Monitoring Fehler: {e}")
+            time.sleep(0.5)
+
+    def wmi_monitor(poll_interval=2):
+        # if polinterval change -> set MB/s and kb/s
+        pythoncom.CoInitialize()
+        c = wmi.WMI(namespace="root\\CIMV2")
+        prev_disk_counters = {}
+        prev_net_stats = {}
+        speeds = get_adapter_speeds()
+
+        active_adapters = get_active_network_adapters()
+        adapter_map = {active: find_best_match(active, list(speeds.keys())) for active in active_adapters}
+
+        try:
+            next_time = time.perf_counter()
+            while not shutdown_event.is_set():
+            #while True:
+                try:
+
+                    # Drives
+                    perf_logical_disks = {
+                        disk.Name.upper(): disk
+                        for disk in c.Win32_PerfRawData_PerfDisk_LogicalDisk()
+                    }
+
+                    for dev, part in selected_components.get('drives', []):
+                        if not selected_components['drives']:
+                            continue
+
+                        perf_disk = perf_logical_disks.get(part)
+                        if not perf_disk:
+                            continue
+
+                        read_bytes = int(perf_disk.DiskReadBytesPerSec)
+                        write_bytes = int(perf_disk.DiskWriteBytesPerSec)
+                        prev_read, prev_write = prev_disk_counters.get(part, (0, 0))
+                        read_diff = max(0, read_bytes - prev_read)
+                        write_diff = max(0, write_bytes - prev_write)
+                        prev_disk_counters[part] = (read_bytes, write_bytes)
+
+                        mb_read = read_diff / 1024 / 1024 / 2
+                        mb_write = write_diff / 1024 / 1024 / 2
+
+                        key = f"{dev}_{part}"
+                        color = get_color(mb_read > 2.0, mb_write > 2.0, mb_read, mb_write)
+
+                        update_tray_color(key, color)
+                        update_tray_tooltip(key, f"{part} R {int(mb_read)} MB/s | W {int(mb_write)} MB/s")
+
+                    # Network
+                    
+                    perf_net_ifaces = c.Win32_PerfRawData_Tcpip_NetworkInterface()
+
+                    for iface in perf_net_ifaces:
+                        iface_name = getattr(iface, 'Name', None)
+                        if not iface_name:
+                            continue
+
+                        adapter_name = find_best_match(iface_name, list(adapter_map.keys()))
+                        if not adapter_name or not selected_components['network']:
+                            continue
+
+                        send_raw = int(iface.BytesSentPersec)
+                        recv_raw = int(iface.BytesReceivedPerSec)
+
+                        #print(f"Raw Network Data - Send: {send_raw}, Recv: {recv_raw}")
+
+                        prev_send, prev_recv = prev_net_stats.get(adapter_name, (0, 0))
+                        send_diff = max(0, send_raw - prev_send)
+                        recv_diff = max(0, recv_raw - prev_recv)
+
+                        #print(f"Network Diff Data - Send: {send_diff}, Recv: {recv_diff}")
+
+                        prev_net_stats[adapter_name] = (send_raw, recv_raw)
+
+                        # Convert bytes to KB
+                        send_kb = send_diff / 1024 / 2
+                        recv_kb = recv_diff / 1024 / 2
+
+                        #print(f"Converted Network Data - Send: {send_kb} KB/s, Recv: {recv_kb} KB/s")
+
+                        update_net_icons(adapter_name, send_kb, recv_kb, selected_components)
+
+                except Exception as e:
+                    print(f"[ERROR] Unified WMI Monitor: {e}")
+
+                next_time += poll_interval
+                time.sleep(max(0, next_time - time.perf_counter()))
+
+        finally:
+            pythoncom.CoUninitialize()
+
+
+
+    if selected_components['cpu']:
+        managed_thread(cpu_monitor)
+        time.sleep(0.3)
+
+    if selected_components['ram']:
+        managed_thread(ram_monitor)
+        time.sleep(0.3)
+        
+    if selected_components['gpu']:
+        managed_thread(gpu_monitor)
+        time.sleep(0.3)
+
+    if selected_components['network']:
+        managed_thread(wmi_monitor)
+        time.sleep(2)
+
+    # Start tray icons for drives based on user selection
+    if selected_components['drives']:
+        device_map = hardware_info.get('drive_map', {})
+        drive_selections = selected_components['drives']
+        start_drive_icons(hardware_info, stop_all_tray_icons, device_map, drive_selections)
+
+
+    print("All tray monitoring components started.")
+
+