pip install pyqt5 psutil matplotlib

pip install gputil

class MatrixRainWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setAttribute(Qt.WA_TranslucentBackground)
        self.characters = "0123456789qwertyuiopasdfghjklzxcvb"
        self.font_size = 12
        self.rain = []
        
        # 初始列數(shù)和行數(shù)，會在resizeEvent中更新
        self.columns = 0
        self.rows = 0
        
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.update_rain)
        self.timer.start(100)
        
    def resizeEvent(self, event):
        # 當窗口大小改變時重新計算列數(shù)和行數(shù)
        font_metrics = QFontMetrics(QFont("MS Gothic", self.font_size))
        char_width = font_metrics.horizontalAdvance("0")
        char_height = font_metrics.height()
        
        if char_width > 0 and char_height > 0:
            self.columns = max(10, self.width() // char_width)
            self.rows = max(5, self.height() // char_height)
        
        self.init_rain()
        super().resizeEvent(event)

class SystemMonitor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("系統(tǒng)資源監(jiān)控系統(tǒng)")
        self.setGeometry(100, 100, 1400, 900)
        
        # 初始化主題
        self.current_theme = "matrix"
        self.init_theme()
        
        # 主部件和布局
        self.main_widget = QWidget()
        self.setCentralWidget(self.main_widget)
        self.main_layout = QVBoxLayout(self.main_widget)
        self.main_layout.setContentsMargins(0, 0, 0, 0)  # 移除邊距
        
        # 添加矩陣數(shù)字雨背景（先添加，確保在最底層）
        self.matrix_rain = MatrixRainWidget(self.main_widget)
        self.matrix_rain.setGeometry(0, 0, self.width(), self.height())
        
        # 創(chuàng)建標簽頁（后添加，確保在上層）
        self.tabs = QTabWidget()
        self.tabs.setStyleSheet("background: transparent;")  # 設置標簽頁透明
        self.main_layout.addWidget(self.tabs)

def create_cpu_tab(self):
    """創(chuàng)建CPU監(jiān)控標簽頁"""
    self.cpu_tab = QWidget()
    self.tabs.addTab(self.cpu_tab, "CPU")
    
    layout = QVBoxLayout(self.cpu_tab)
    
    # CPU信息標簽
    self.cpu_info_label = QLabel()
    self.cpu_info_label.setFont(QFont("Consolas", 10))
    layout.addWidget(self.cpu_info_label)
    
    # CPU使用率波形圖
    self.cpu_fig, self.cpu_ax = plt.subplots(figsize=(10, 6))
    self.setup_chart_style(self.cpu_fig, self.cpu_ax, "CPU Usage (%)")
    
    # 初始化CPU核心線
    self.cpu_lines = []
    for i in range(psutil.cpu_count()):
        line, = self.cpu_ax.plot([], [], label=f'Core {i+1}', color=self.get_green_color(i))
        self.cpu_lines.append(line)
    
    self.cpu_ax.set_ylim(0, 100)
    self.cpu_ax.set_xlim(0, 60)
    self.cpu_ax.legend(facecolor='black', labelcolor='#00FF00')
    
    self.cpu_canvas = FigureCanvas(self.cpu_fig)
    layout.addWidget(self.cpu_canvas)

def update_all(self):
    """更新所有監(jiān)控數(shù)據(jù)"""
    self.update_cpu()
    self.update_memory()
    self.update_gpu()
    self.update_network()
    self.update_disk()
    self.update_processes()
    self.update_sensors()
    self.update_battery()
    
    # 更新狀態(tài)欄
    self.status_bar.setText(time.strftime("%Y-%m-%d %H:%M:%S") + 
                          " | System Monitoring Active | Press Ctrl+Q to exit")

def update_cpu(self):
    """更新CPU數(shù)據(jù)"""
    # 獲取CPU使用率
    cpu_percent = psutil.cpu_percent(interval=0.1, percpu=True)
    
    # 更新數(shù)據(jù)
    for i, percent in enumerate(cpu_percent):
        self.cpu_data[i].append(percent)
        if len(self.cpu_data[i]) > 60:  # 保留60秒數(shù)據(jù)
            self.cpu_data[i] = self.cpu_data[i][-60:]
    
    # 更新圖表
    for i, line in enumerate(self.cpu_lines):
        line.set_data(range(len(self.cpu_data[i])), self.cpu_data[i])
    
    # 自動調(diào)整Y軸范圍
    max_val = max([max(core) for core in self.cpu_data if core] + [10])
    self.cpu_ax.set_ylim(0, max(100, max_val * 1.1))

import sys
import time
import psutil
import numpy as np
from PyQt5.QtCore import Qt, QTimer, QRect, QPoint, pyqtSignal, QThread
from PyQt5.QtGui import QFont, QColor, QPainter, QPen, QLinearGradient, QBrush, QFontMetrics
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
                            QLabel, QTabWidget, QGridLayout, QMenu, QAction, QToolBar,
                            QDockWidget, QScrollArea, QSizePolicy, QSplitter,
                            QTableWidget, QTableWidgetItem, QHeaderView)
import matplotlib.pyplot as plt
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar

class MatrixRainWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setAttribute(Qt.WA_TranslucentBackground)
        self.characters = "0123456789qwertyuiopasdfghjklzxcvb"
        self.font_size = 12
        self.rain = []
        
        # 初始列數(shù)和行數(shù)，會在resizeEvent中更新
        self.columns = 0
        self.rows = 0
        
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.update_rain)
        self.timer.start(0)
        
    def resizeEvent(self, event):
        # 當窗口大小改變時重新計算列數(shù)和行數(shù)
        font_metrics = QFontMetrics(QFont("MS Gothic", self.font_size))
        char_width = font_metrics.horizontalAdvance("0")
        char_height = font_metrics.height()
        
        if char_width > 0 and char_height > 0:
            self.columns = max(10, self.width() // char_width)
            self.rows = max(5, self.height() // char_height)
        
        self.init_rain()
        super().resizeEvent(event)
        
    def init_rain(self):
        self.rain = []
        for i in range(self.columns):
            length = np.random.randint(5, self.rows)
            speed = np.random.uniform(0.5, 1.5)
            start_pos = np.random.randint(-self.rows, 0)
            self.rain.append({
                'length': length,
                'speed': speed,
                'position': start_pos,
                'chars': [np.random.choice(list(self.characters)) for _ in range(length)],
                'brightness': [max(0.1, 1 - i/length) for i in range(length)]
            })
    
    def update_rain(self):
        for drop in self.rain:
            drop['position'] += drop['speed']
            if drop['position'] - drop['length'] > self.rows:
                drop['position'] = np.random.randint(-self.rows, 0)
                drop['chars'] = [np.random.choice(list(self.characters)) for _ in range(drop['length'])]
        self.update()
    
    def paintEvent(self, event):
        if not self.rain:
            return
            
        painter = QPainter(self)
        painter.setFont(QFont("MS Gothic", self.font_size))
        
        font_metrics = painter.fontMetrics()
        char_width = font_metrics.horizontalAdvance("0")
        char_height = font_metrics.height()
        
        if char_width == 0 or char_height == 0:
            return
            
        for i, drop in enumerate(self.rain):
            x = i * char_width
            for j in range(drop['length']):
                y_pos = drop['position'] - j
                if 0 <= y_pos < self.rows:
                    y = y_pos * char_height
                    brightness = drop['brightness'][j]
                    color = QColor(0, int(255 * brightness), 0)
                    painter.setPen(color)
                    painter.drawText(QPoint(int(x), int(y)), drop['chars'][j])

class SystemMonitor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("資源監(jiān)控系統(tǒng)-By 創(chuàng)客白澤")
        self.setGeometry(100, 100, 1400, 900)
        
        # 初始化主題
        self.current_theme = "matrix"
        self.init_theme()
        
        # 主部件和布局
        self.main_widget = QWidget()
        self.setCentralWidget(self.main_widget)
        self.main_layout = QVBoxLayout(self.main_widget)
        self.main_layout.setContentsMargins(0, 0, 0, 0)  # 移除邊距
        
        # 添加矩陣數(shù)字雨背景（先添加，確保在最底層）
        self.matrix_rain = MatrixRainWidget(self.main_widget)
        self.matrix_rain.setGeometry(0, 0, self.width(), self.height())
        
        # 創(chuàng)建標簽頁（后添加，確保在上層）
        self.tabs = QTabWidget()
        self.tabs.setStyleSheet("background: transparent;")  # 設置標簽頁透明
        self.main_layout.addWidget(self.tabs)
        
        # 創(chuàng)建各個監(jiān)控標簽頁
        self.create_cpu_tab()
        self.create_memory_tab()
        self.create_gpu_tab()
        self.create_network_tab()
        self.create_disk_tab()
        self.create_process_tab()
        self.create_sensors_tab()
        self.create_battery_tab()
        
        # 底部狀態(tài)欄
        self.status_bar = QLabel()
        self.status_bar.setAlignment(Qt.AlignCenter)
        self.status_bar.setFont(QFont("Consolas", 10))
        self.main_layout.addWidget(self.status_bar)
        
        # 數(shù)據(jù)初始化
        self.init_data()
        
        # 工具欄
        self.create_toolbar()
        
        # 右鍵菜單
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_context_menu)
        
        # 定時器更新數(shù)據(jù)
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_all)
        self.timer.start(1000)
        
        # 初始化數(shù)據(jù)
        self.update_all()
    
    def resizeEvent(self, event):
        # 更新數(shù)字雨部件的大小
        if hasattr(self, 'matrix_rain'):
            self.matrix_rain.setGeometry(0, 0, self.width(), self.height())
        super().resizeEvent(event)
    
    def init_theme(self):
        """初始化主題樣式"""
        if self.current_theme == "matrix":
            self.setStyleSheet("""
                QMainWindow {
                    background-color: black;
                }
                QLabel {
                    color: #00FF00;
                    font-family: Consolas, Courier New, monospace;
                }
                QTabWidget::pane {
                    border: 1px solid #00FF00;
                    background: rgba(0, 0, 0, 200);
                }
                QTabBar::tab {
                    background: black;
                    color: #00FF00;
                    border: 1px solid #00FF00;
                    padding: 5px;
                }
                QTabBar::tab:selected {
                    background: #003300;
                }
                QToolBar {
                    background: rgba(0, 20, 0, 150);
                    border: 1px solid #00AA00;
                }
                QToolButton {
                    color: #00FF00;
                    background: transparent;
                    padding: 5px;
                }
                QToolButton:hover {
                    background: rgba(0, 100, 0, 100);
                }
                QScrollArea {
                    background: transparent;
                    border: none;
                }
                QTableView {
                    background: rgba(0, 10, 0, 150);
                    color: #00FF00;
                    gridline-color: #005500;
                    font-family: Consolas;
                }
                QHeaderView::section {
                    background-color: rgba(0, 30, 0, 150);
                    color: #00FF00;
                    padding: 5px;
                    border: 1px solid #005500;
                }
            """)
    
    def create_cpu_tab(self):
        """創(chuàng)建CPU監(jiān)控標簽頁"""
        self.cpu_tab = QWidget()
        self.tabs.addTab(self.cpu_tab, "CPU")
        
        layout = QVBoxLayout(self.cpu_tab)
        
        # CPU信息標簽
        self.cpu_info_label = QLabel()
        self.cpu_info_label.setFont(QFont("Consolas", 10))
        layout.addWidget(self.cpu_info_label)
        
        # CPU使用率波形圖
        self.cpu_fig, self.cpu_ax = plt.subplots(figsize=(10, 6))
        self.setup_chart_style(self.cpu_fig, self.cpu_ax, "CPU Usage (%)")
        
        # 初始化CPU核心線
        self.cpu_lines = []
        for i in range(psutil.cpu_count()):
            line, = self.cpu_ax.plot([], [], label=f'Core {i+1}', color=self.get_green_color(i))
            self.cpu_lines.append(line)
        
        self.cpu_ax.set_ylim(0, 100)
        self.cpu_ax.set_xlim(0, 60)
        self.cpu_ax.legend(facecolor='black', labelcolor='#00FF00')
        
        self.cpu_canvas = FigureCanvas(self.cpu_fig)
        layout.addWidget(self.cpu_canvas)
        
        # 添加工具欄
        cpu_toolbar = NavigationToolbar(self.cpu_canvas, self)
        layout.addWidget(cpu_toolbar)
    
    def create_memory_tab(self):
        """創(chuàng)建內(nèi)存監(jiān)控標簽頁"""
        self.mem_tab = QWidget()
        self.tabs.addTab(self.mem_tab, "Memory")
        
        layout = QVBoxLayout(self.mem_tab)
        
        # 內(nèi)存信息標簽
        self.mem_info_label = QLabel()
        self.mem_info_label.setFont(QFont("Consolas", 10))
        layout.addWidget(self.mem_info_label)
        
        # 內(nèi)存使用率波形圖
        self.mem_fig, self.mem_ax = plt.subplots(figsize=(10, 6))
        self.setup_chart_style(self.mem_fig, self.mem_ax, "Memory Usage (%)")
        
        self.mem_line, = self.mem_ax.plot([], [], label='Memory Usage', color='#00FF00')
        self.mem_ax.set_ylim(0, 100)
        self.mem_ax.set_xlim(0, 60)
        self.mem_ax.legend(facecolor='black', labelcolor='#00FF00')
        
        self.mem_canvas = FigureCanvas(self.mem_fig)
        layout.addWidget(self.mem_canvas)
        
        # 添加工具欄
        mem_toolbar = NavigationToolbar(self.mem_canvas, self)
        layout.addWidget(mem_toolbar)
        
        # 內(nèi)存詳細信息網(wǎng)格
        self.mem_detail_grid = QGridLayout()
        layout.addLayout(self.mem_detail_grid)
        
        self.mem_detail_labels = {
            'total': QLabel(),
            'available': QLabel(),
            'used': QLabel(),
            'free': QLabel(),
            'percent': QLabel(),
            'swap_total': QLabel(),
            'swap_used': QLabel(),
            'swap_free': QLabel(),
            'swap_percent': QLabel()
        }
        
        row = 0
        col = 0
        for key, label in self.mem_detail_labels.items():
            label.setFont(QFont("Consolas", 9))
            self.mem_detail_grid.addWidget(QLabel(key.replace('_', ' ').title() + ":"), row, col)
            self.mem_detail_grid.addWidget(label, row, col+1)
            col += 2
            if col >= 4:
                col = 0
                row += 1
    
    def create_gpu_tab(self):
        """創(chuàng)建顯卡監(jiān)控標簽頁"""
        self.gpu_tab = QWidget()
        self.tabs.addTab(self.gpu_tab, "GPU")
        
        layout = QVBoxLayout(self.gpu_tab)
        
        # GPU信息標簽
        self.gpu_info_label = QLabel("GPU monitoring requires additional libraries like GPUtil")
        self.gpu_info_label.setFont(QFont("Consolas", 10))
        layout.addWidget(self.gpu_info_label)
        
        # GPU使用率波形圖
        self.gpu_fig, self.gpu_ax = plt.subplots(figsize=(10, 6))
        self.setup_chart_style(self.gpu_fig, self.gpu_ax, "GPU Usage (%)")
        
        self.gpu_line, = self.gpu_ax.plot([], [], label='GPU Usage', color='#00FF00')
        self.gpu_ax.set_ylim(0, 100)
        self.gpu_ax.set_xlim(0, 60)
        self.gpu_ax.legend(facecolor='black', labelcolor='#00FF00')
        
        self.gpu_canvas = FigureCanvas(self.gpu_fig)
        layout.addWidget(self.gpu_canvas)
        
        # 添加工具欄
        gpu_toolbar = NavigationToolbar(self.gpu_canvas, self)
        layout.addWidget(gpu_toolbar)
        
        # GPU詳細信息
        self.gpu_detail_label = QLabel()
        self.gpu_detail_label.setFont(QFont("Consolas", 9))
        layout.addWidget(self.gpu_detail_label)
    
    def create_network_tab(self):
        """創(chuàng)建網(wǎng)絡監(jiān)控標簽頁"""
        self.net_tab = QWidget()
        self.tabs.addTab(self.net_tab, "Network")
        
        layout = QVBoxLayout(self.net_tab)
        
        # 網(wǎng)絡信息標簽
        self.net_info_label = QLabel()
        self.net_info_label.setFont(QFont("Consolas", 10))
        layout.addWidget(self.net_info_label)
        
        # 網(wǎng)絡使用率波形圖
        self.net_fig, self.net_ax = plt.subplots(figsize=(10, 6))
        self.setup_chart_style(self.net_fig, self.net_ax, "Network Traffic (MB/s)")
        
        self.net_sent_line, = self.net_ax.plot([], [], label='Sent', color='#00FF00')
        self.net_recv_line, = self.net_ax.plot([], [], label='Received', color='#00CC00')
        self.net_ax.set_ylim(0, 10)
        self.net_ax.set_xlim(0, 60)
        self.net_ax.legend(facecolor='black', labelcolor='#00FF00')
        
        self.net_canvas = FigureCanvas(self.net_fig)
        layout.addWidget(self.net_canvas)
        
        # 添加工具欄
        net_toolbar = NavigationToolbar(self.net_canvas, self)
        layout.addWidget(net_toolbar)
        
        # 網(wǎng)絡詳細信息
        self.net_detail_label = QLabel()
        self.net_detail_label.setFont(QFont("Consolas", 9))
        layout.addWidget(self.net_detail_label)
    
    def create_disk_tab(self):
        """創(chuàng)建磁盤監(jiān)控標簽頁"""
        self.disk_tab = QWidget()
        self.tabs.addTab(self.disk_tab, "Disk")
        
        layout = QVBoxLayout(self.disk_tab)
        
        # 磁盤信息標簽
        self.disk_info_label = QLabel()
        self.disk_info_label.setFont(QFont("Consolas", 10))
        layout.addWidget(self.disk_info_label)
        
        # 磁盤使用率波形圖
        self.disk_fig, self.disk_ax = plt.subplots(figsize=(10, 6))
        self.setup_chart_style(self.disk_fig, self.disk_ax, "Disk I/O (MB/s)")
        
        self.disk_read_line, = self.disk_ax.plot([], [], label='Read', color='#00FF00')
        self.disk_write_line, = self.disk_ax.plot([], [], label='Write', color='#00CC00')
        self.disk_ax.set_ylim(0, 10)
        self.disk_ax.set_xlim(0, 60)
        self.disk_ax.legend(facecolor='black', labelcolor='#00FF00')
        
        self.disk_canvas = FigureCanvas(self.disk_fig)
        layout.addWidget(self.disk_canvas)
        
        # 添加工具欄
        disk_toolbar = NavigationToolbar(self.disk_canvas, self)
        layout.addWidget(disk_toolbar)
        
        # 磁盤分區(qū)信息
        self.disk_partitions_label = QLabel()
        self.disk_partitions_label.setFont(QFont("Consolas", 9))
        layout.addWidget(self.disk_partitions_label)
    
    def create_process_tab(self):
        """創(chuàng)建進程監(jiān)控標簽頁"""
        self.process_tab = QWidget()
        self.tabs.addTab(self.process_tab, "Processes")
        
        layout = QVBoxLayout(self.process_tab)
        
        # 進程信息標簽
        self.process_info_label = QLabel("系統(tǒng)進程監(jiān)控 - 按CPU使用率排序")
        self.process_info_label.setFont(QFont("Consolas", 12))
        layout.addWidget(self.process_info_label)
        
        # 進程表格
        self.process_table = QTableWidget()
        self.process_table.setColumnCount(6)
        self.process_table.setHorizontalHeaderLabels(["PID", "名稱", "CPU%", "內(nèi)存%", "狀態(tài)", "用戶"])
        self.process_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        self.process_table.setSortingEnabled(True)
        
        # 添加滾動區(qū)域
        scroll = QScrollArea()
        scroll.setWidget(self.process_table)
        scroll.setWidgetResizable(True)
        layout.addWidget(scroll)
    
    def create_sensors_tab(self):
        """創(chuàng)建傳感器監(jiān)控標簽頁"""
        self.sensors_tab = QWidget()
        self.tabs.addTab(self.sensors_tab, "Sensors")
        
        layout = QVBoxLayout(self.sensors_tab)
        
        # 傳感器信息標簽
        self.sensors_info_label = QLabel("系統(tǒng)傳感器數(shù)據(jù) - 溫度/風扇/電壓")
        self.sensors_info_label.setFont(QFont("Consolas", 12))
        layout.addWidget(self.sensors_info_label)
        
        # 溫度監(jiān)控圖表
        self.temp_fig, self.temp_ax = plt.subplots(figsize=(10, 4))
        self.setup_chart_style(self.temp_fig, self.temp_ax, "Temperature (°C)")
        
        self.temp_lines = {}
        self.temp_data = {}
        
        # 初始化溫度線
        temps = self.get_temperatures()
        for name in temps.keys():
            self.temp_data[name] = []
            line, = self.temp_ax.plot([], [], label=name, color=self.get_green_color(len(self.temp_lines)))
            self.temp_lines[name] = line
        
        self.temp_ax.legend(facecolor='black', labelcolor='#00FF00')
        self.temp_canvas = FigureCanvas(self.temp_fig)
        layout.addWidget(self.temp_canvas)
        
        # 添加工具欄
        temp_toolbar = NavigationToolbar(self.temp_canvas, self)
        layout.addWidget(temp_toolbar)
        
        # 傳感器詳細信息
        self.sensors_detail_label = QLabel()
        self.sensors_detail_label.setFont(QFont("Consolas", 9))
        layout.addWidget(self.sensors_detail_label)
    
    def create_battery_tab(self):
        """創(chuàng)建電池監(jiān)控標簽頁"""
        self.battery_tab = QWidget()
        self.tabs.addTab(self.battery_tab, "Battery")
        
        layout = QVBoxLayout(self.battery_tab)
        
        # 電池信息標簽
        self.battery_info_label = QLabel()
        self.battery_info_label.setFont(QFont("Consolas", 12))
        layout.addWidget(self.battery_info_label)
        
        # 電池狀態(tài)圖表
        self.batt_fig, self.batt_ax = plt.subplots(figsize=(10, 4))
        self.setup_chart_style(self.batt_fig, self.batt_ax, "Battery Level (%)")
        
        self.batt_line, = self.batt_ax.plot([], [], label='Battery', color='#00FF00')
        self.batt_ax.set_ylim(0, 100)
        self.batt_ax.set_xlim(0, 60)
        self.batt_ax.legend(facecolor='black', labelcolor='#00FF00')
        
        self.batt_canvas = FigureCanvas(self.batt_fig)
        layout.addWidget(self.batt_canvas)
        
        # 添加工具欄
        batt_toolbar = NavigationToolbar(self.batt_canvas, self)
        layout.addWidget(batt_toolbar)
        
        # 電池詳細信息
        self.batt_detail_label = QLabel()
        self.batt_detail_label.setFont(QFont("Consolas", 9))
        layout.addWidget(self.batt_detail_label)
        
        # 初始化電池數(shù)據(jù)
        self.batt_data = []
    
    def setup_chart_style(self, fig, ax, title):
        """設置圖表樣式"""
        fig.patch.set_facecolor('black')
        ax.set_facecolor('black')
        ax.tick_params(axis='x', colors='#00FF00')
        ax.tick_params(axis='y', colors='#00FF00')
        for spine in ax.spines.values():
            spine.set_color('#00FF00')
        ax.title.set_color('#00FF00')
        ax.set_title(title)
    
    def get_green_color(self, index):
        """獲取不同深淺的綠色"""
        intensity = 0.3 + (index % 8) * 0.1
        return (0, intensity, 0, 1)
    
    def create_toolbar(self):
        """創(chuàng)建工具欄"""
        toolbar = QToolBar("主工具欄")
        self.addToolBar(Qt.TopToolBarArea, toolbar)
        
        # 主題切換
        theme_menu = QMenu("主題", self)
        matrix_action = QAction("矩陣風格", self)
        dark_action = QAction("暗黑風格", self)
        tech_action = QAction("科技風格", self)
        
        matrix_action.triggered.connect(lambda: self.change_theme("matrix"))
        dark_action.triggered.connect(lambda: self.change_theme("dark"))
        tech_action.triggered.connect(lambda: self.change_theme("tech"))
        
        theme_menu.addAction(matrix_action)
        theme_menu.addAction(dark_action)
        theme_menu.addAction(tech_action)
        
        theme_button = toolbar.addAction("主題")
        theme_button.setMenu(theme_menu)
        
        # 刷新控制
        refresh_menu = QMenu("刷新率", self)
        fast_action = QAction("快速 (500ms)", self)
        normal_action = QAction("正常 (1s)", self)
        slow_action = QAction("慢速 (2s)", self)
        
        fast_action.triggered.connect(lambda: self.change_refresh_rate(500))
        normal_action.triggered.connect(lambda: self.change_refresh_rate(1000))
        slow_action.triggered.connect(lambda: self.change_refresh_rate(2000))
        
        refresh_menu.addAction(fast_action)
        refresh_menu.addAction(normal_action)
        refresh_menu.addAction(slow_action)
        
        refresh_button = toolbar.addAction("刷新率")
        refresh_button.setMenu(refresh_menu)
        
        # 窗口控制
        toolbar.addAction("分離窗口", self.detach_window)
        toolbar.addAction("重置布局", self.reset_layout)
    
    def show_context_menu(self, pos):
        """顯示右鍵菜單"""
        context_menu = QMenu(self)
        
        screenshot_action = QAction("截圖保存", self)
        screenshot_action.triggered.connect(self.save_screenshot)
        
        export_action = QAction("導出數(shù)據(jù)", self)
        export_action.triggered.connect(self.export_data)
        
        context_menu.addAction(screenshot_action)
        context_menu.addAction(export_action)
        context_menu.exec_(self.mapToGlobal(pos))
    
    def init_data(self):
        """初始化所有數(shù)據(jù)容器"""
        # CPU數(shù)據(jù)
        self.cpu_data = [[] for _ in range(psutil.cpu_count())]
        
        # 內(nèi)存數(shù)據(jù)
        self.mem_data = []
        
        # GPU數(shù)據(jù)
        self.gpu_data = []
        
        # 網(wǎng)絡數(shù)據(jù)
        self.net_sent_data = []
        self.net_recv_data = []
        self.last_net_io = None
        self.last_net_time = time.time()
        
        # 磁盤數(shù)據(jù)
        self.disk_read_data = []
        self.disk_write_data = []
        self.last_disk_io = None
        self.last_disk_time = time.time()
        
        # 溫度數(shù)據(jù)
        self.temp_data = {name: [] for name in self.get_temperatures().keys()}
        
        # 電池數(shù)據(jù)
        self.batt_data = []
    
    def update_all(self):
        """更新所有監(jiān)控數(shù)據(jù)"""
        self.update_cpu()
        self.update_memory()
        self.update_gpu()
        self.update_network()
        self.update_disk()
        self.update_processes()
        self.update_sensors()
        self.update_battery()
        
        # 更新狀態(tài)欄
        self.status_bar.setText(time.strftime("%Y-%m-%d %H:%M:%S") + 
                              " | System Monitoring Active | Press Ctrl+Q to exit")
    
    def update_cpu(self):
        """更新CPU數(shù)據(jù)"""
        # 獲取CPU使用率
        cpu_percent = psutil.cpu_percent(interval=0.1, percpu=True)
        
        # 更新數(shù)據(jù)
        for i, percent in enumerate(cpu_percent):
            self.cpu_data[i].append(percent)
            if len(self.cpu_data[i]) > 60:  # 保留60秒數(shù)據(jù)
                self.cpu_data[i] = self.cpu_data[i][-60:]
        
        # 更新圖表
        for i, line in enumerate(self.cpu_lines):
            line.set_data(range(len(self.cpu_data[i])), self.cpu_data[i])
        
        # 自動調(diào)整Y軸范圍
        max_val = max([max(core) for core in self.cpu_data if core] + [10])
        self.cpu_ax.set_ylim(0, max(100, max_val * 1.1))
        
        # 更新CPU信息標簽
        cpu_count = psutil.cpu_count()
        cpu_freq = psutil.cpu_freq()
        info_text = (f"CPU: {psutil.cpu_percent()}% Total | "
                    f"Cores: {cpu_count} | "
                    f"Frequency: {cpu_freq.current:.2f} MHz (Max: {cpu_freq.max:.2f} MHz)")
        self.cpu_info_label.setText(info_text)
        
        # 重繪圖表
        self.cpu_canvas.draw()
    
    def update_memory(self):
        """更新內(nèi)存數(shù)據(jù)"""
        # 獲取內(nèi)存使用情況
        mem = psutil.virtual_memory()
        swap = psutil.swap_memory()
        
        # 更新數(shù)據(jù)
        self.mem_data.append(mem.percent)
        if len(self.mem_data) > 60:
            self.mem_data = self.mem_data[-60:]
        
        # 更新圖表
        self.mem_line.set_data(range(len(self.mem_data)), self.mem_data)
        
        # 自動調(diào)整Y軸范圍
        max_val = max(self.mem_data + [10])
        self.mem_ax.set_ylim(0, max(100, max_val * 1.1))
        
        # 更新內(nèi)存信息標簽
        info_text = (f"Memory: {mem.percent}% Used | "
                    f"Total: {self.format_bytes(mem.total)} | "
                    f"Available: {self.format_bytes(mem.available)} | "
                    f"Swap: {swap.percent}% Used ({self.format_bytes(swap.used)}/{self.format_bytes(swap.total)})")
        self.mem_info_label.setText(info_text)
        
        # 更新詳細內(nèi)存信息
        self.mem_detail_labels['total'].setText(self.format_bytes(mem.total))
        self.mem_detail_labels['available'].setText(self.format_bytes(mem.available))
        self.mem_detail_labels['used'].setText(self.format_bytes(mem.used))
        self.mem_detail_labels['free'].setText(self.format_bytes(mem.free))
        self.mem_detail_labels['percent'].setText(f"{mem.percent}%")
        self.mem_detail_labels['swap_total'].setText(self.format_bytes(swap.total))
        self.mem_detail_labels['swap_used'].setText(self.format_bytes(swap.used))
        self.mem_detail_labels['swap_free'].setText(self.format_bytes(swap.free))
        self.mem_detail_labels['swap_percent'].setText(f"{swap.percent}%")
        
        # 重繪圖表
        self.mem_canvas.draw()
    
    def update_gpu(self):
        """更新GPU數(shù)據(jù)"""
        try:
            import GPUtil
            gpus = GPUtil.getGPUs()
            
            if gpus:
                gpu = gpus[0]  # 只顯示第一個GPU
                gpu_percent = gpu.load * 100
                
                # 更新數(shù)據(jù)
                self.gpu_data.append(gpu_percent)
                if len(self.gpu_data) > 60:
                    self.gpu_data = self.gpu_data[-60:]
                
                # 更新圖表
                self.gpu_line.set_data(range(len(self.gpu_data)), self.gpu_data)
                
                # 自動調(diào)整Y軸范圍
                max_val = max(self.gpu_data + [10])
                self.gpu_ax.set_ylim(0, max(100, max_val * 1.1))
                
                # 更新GPU信息
                info_text = (f"GPU: {gpu.name} | "
                            f"Usage: {gpu_percent:.1f}% | "
                            f"Memory: {gpu.memoryUsed:.1f}/{gpu.memoryTotal:.1f} MB ({gpu.memoryUtil*100:.1f}%) | "
                            f"Temperature: {gpu.temperature}°C")
                self.gpu_info_label.setText(info_text)
                
                # 更新GPU詳細信息
                detail_text = (f"Driver: {gpu.driver}\n"
                              f"UUID: {gpu.uuid}\n"
                              f"Serial: {gpu.serial}\n"
                              f"Display Mode: {gpu.display_mode}\n"
                              f"Display Active: {gpu.display_active}")
                self.gpu_detail_label.setText(detail_text)
                
                # 重繪圖表
                self.gpu_canvas.draw()
            else:
                self.gpu_info_label.setText("No GPU detected")
        except ImportError:
            self.gpu_info_label.setText("GPUtil library not installed. Install with: pip install gputil")
        except Exception as e:
            self.gpu_info_label.setText(f"GPU monitoring error: {str(e)}")
    
    def update_network(self):
        """更新網(wǎng)絡數(shù)據(jù)"""
        # 獲取網(wǎng)絡IO
        net_io = psutil.net_io_counters()
        
        # 如果是第一次調(diào)用，只保存當前值不計算
        if self.last_net_io is None:
            self.last_net_io = net_io
            self.last_net_time = time.time()
            return  # 第一次不進行計算
        
        # 計算每秒的發(fā)送/接收量 (MB)
        time_passed = time.time() - self.last_net_time
        if time_passed > 0:  # 避免除以0
            sent_mb = (net_io.bytes_sent - self.last_net_io.bytes_sent) / (1024 * 1024 * time_passed)
            recv_mb = (net_io.bytes_recv - self.last_net_io.bytes_recv) / (1024 * 1024 * time_passed)
            
            # 更新數(shù)據(jù)
            self.net_sent_data.append(sent_mb)
            self.net_recv_data.append(recv_mb)
            if len(self.net_sent_data) > 60:
                self.net_sent_data = self.net_sent_data[-60:]
                self.net_recv_data = self.net_recv_data[-60:]
            
            # 更新圖表
            self.net_sent_line.set_data(range(len(self.net_sent_data)), self.net_sent_data)
            self.net_recv_line.set_data(range(len(self.net_recv_data)), self.net_recv_data)
            
            # 自動調(diào)整Y軸范圍
            max_val = max(max(self.net_sent_data + [0.1]), max(self.net_recv_data + [0.1]))
            self.net_ax.set_ylim(0, max(10, max_val * 1.1))
            
            # 更新網(wǎng)絡信息
            info_text = (f"Network: Sent {sent_mb:.2f} MB/s | Received {recv_mb:.2f} MB/s | "
                        f"Total Sent: {self.format_bytes(net_io.bytes_sent)} | "
                        f"Total Received: {self.format_bytes(net_io.bytes_recv)}")
            self.net_info_label.setText(info_text)
            
            # 更新網(wǎng)絡詳細信息
            net_if_addrs = psutil.net_if_addrs()
            net_if_stats = psutil.net_if_stats()
            
            detail_text = "Network Interfaces:\n"
            for interface, addrs in net_if_addrs.items():
                stats = net_if_stats.get(interface, None)
                detail_text += (f"\n{interface}: {stats.speed}Mbps " if stats else f"\n{interface}: ")
                for addr in addrs:
                    if addr.family == psutil.AF_LINK:
                        detail_text += f"MAC: {addr.address} "
                    elif addr.family == 2:  # AF_INET
                        detail_text += f"IPv4: {addr.address} "
                    elif addr.family == 23:  # AF_INET6
                        detail_text += f"IPv6: {addr.address} "
            
            self.net_detail_label.setText(detail_text)
            
            # 重繪圖表
            self.net_canvas.draw()
        
        # 保存當前值供下次比較
        self.last_net_io = net_io
        self.last_net_time = time.time()
    
    def update_disk(self):
        """更新磁盤數(shù)據(jù)"""
        # 獲取磁盤IO
        disk_io = psutil.disk_io_counters()
        
        # 如果是第一次調(diào)用，只保存當前值不計算
        if self.last_disk_io is None:
            self.last_disk_io = disk_io
            self.last_disk_time = time.time()
            return  # 第一次不進行計算
        
        # 計算每秒的讀/寫量 (MB)
        time_passed = time.time() - self.last_disk_time
        if time_passed > 0:  # 避免除以0
            read_mb = (disk_io.read_bytes - self.last_disk_io.read_bytes) / (1024 * 1024 * time_passed)
            write_mb = (disk_io.write_bytes - self.last_disk_io.write_bytes) / (1024 * 1024 * time_passed)
            
            # 更新數(shù)據(jù)
            self.disk_read_data.append(read_mb)
            self.disk_write_data.append(write_mb)
            if len(self.disk_read_data) > 60:
                self.disk_read_data = self.disk_read_data[-60:]
                self.disk_write_data = self.disk_write_data[-60:]
            
            # 更新圖表
            self.disk_read_line.set_data(range(len(self.disk_read_data)), self.disk_read_data)
            self.disk_write_line.set_data(range(len(self.disk_write_data)), self.disk_write_data)
            
            # 自動調(diào)整Y軸范圍
            max_val = max(max(self.disk_read_data + [0.1]), max(self.disk_write_data + [0.1]))
            self.disk_ax.set_ylim(0, max(10, max_val * 1.1))
            
            # 更新磁盤信息
            info_text = (f"Disk: Read {read_mb:.2f} MB/s | Write {write_mb:.2f} MB/s | "
                        f"Total Read: {self.format_bytes(disk_io.read_bytes)} | "
                        f"Total Write: {self.format_bytes(disk_io.write_bytes)}")
            self.disk_info_label.setText(info_text)
            
            # 重繪圖表
            self.disk_canvas.draw()
        
        # 保存當前值供下次比較
        self.last_disk_io = disk_io
        self.last_disk_time = time.time()
        
        # 更新磁盤分區(qū)信息
        partitions = psutil.disk_partitions()
        usage = [psutil.disk_usage(p.mountpoint) for p in partitions]
        
        detail_text = "Disk Partitions:\n"
        for p, u in zip(partitions, usage):
            detail_text += (f"\n{p.device} -> {p.mountpoint} ({p.fstype}) "
                          f"Total: {self.format_bytes(u.total)} "
                          f"Used: {self.format_bytes(u.used)} ({u.percent}%) "
                          f"Free: {self.format_bytes(u.free)}")
        
        self.disk_partitions_label.setText(detail_text)
    
    def update_processes(self):
        """更新進程信息"""
        try:
            # 獲取進程列表并按CPU排序
            processes = []
            for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent', 'status', 'username']):
                try:
                    processes.append((
                        proc.info['pid'],
                        proc.info['name'],
                        proc.info['cpu_percent'],
                        proc.info['memory_percent'],
                        proc.info['status'],
                        proc.info['username'] or 'N/A'
                    ))
                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                    pass
            
            # 按CPU使用率排序
            processes.sort(key=lambda p: p[2], reverse=True)
            
            # 更新表格
            self.process_table.setRowCount(len(processes[:50]))  # 只顯示前50個
            for row, proc in enumerate(processes[:50]):
                for col, val in enumerate(proc):
                    item = QTableWidgetItem(str(val))
                    item.setTextAlignment(Qt.AlignCenter)
                    
                    # 高亮顯示高資源占用的進程
                    if col == 2 and val > 50:  # CPU > 50%
                        item.setForeground(QColor(255, 0, 0))
                    elif col == 3 and val > 10:  # 內(nèi)存 > 10%
                        item.setForeground(QColor(255, 165, 0))
                    
                    self.process_table.setItem(row, col, item)
            
            # 更新進程信息標簽
            total_procs = len(processes)
            running_procs = sum(1 for p in processes if p[4] == 'running')
            self.process_info_label.setText(
                f"系統(tǒng)進程監(jiān)控 | 總數(shù): {total_procs} | 運行中: {running_procs} | 顯示CPU最高的50個進程")
                
        except Exception as e:
            self.process_info_label.setText(f"進程監(jiān)控錯誤: {str(e)}")
    
    def update_sensors(self):
        """更新傳感器數(shù)據(jù)"""
        try:
            temps = self.get_temperatures()
            
            # 更新溫度數(shù)據(jù)
            for name, temp in temps.items():
                if name in self.temp_data:
                    self.temp_data[name].append(temp)
                    if len(self.temp_data[name]) > 60:
                        self.temp_data[name] = self.temp_data[name][-60:]
                    
                    # 更新圖表
                    if name in self.temp_lines:
                        self.temp_lines[name].set_data(range(len(self.temp_data[name])), self.temp_data[name])
            
            # 自動調(diào)整Y軸范圍
            max_temp = max([max(data) for data in self.temp_data.values() if data] + [50])
            self.temp_ax.set_ylim(0, max(90, max_temp * 1.1))
            
            # 更新傳感器信息
            fan_info = self.get_fan_speeds()
            voltage_info = self.get_voltages()
            
            info_text = "傳感器數(shù)據(jù):\n"
            info_text += "\n溫度:\n"
            for name, temp in temps.items():
                info_text += f"{name}: {temp}°C  "
            
            if fan_info:
                info_text += "\n\n風扇轉速:\n"
                for name, speed in fan_info.items():
                    info_text += f"{name}: {speed}RPM  "
            
            if voltage_info:
                info_text += "\n\n電壓:\n"
                for name, volt in voltage_info.items():
                    info_text += f"{name}: {volt}V  "
            
            self.sensors_detail_label.setText(info_text)
            self.temp_canvas.draw()
            
        except Exception as e:
            self.sensors_detail_label.setText(f"傳感器監(jiān)控錯誤: {str(e)}")
    
    def update_battery(self):
        """更新電池信息"""
        try:
            battery = psutil.sensors_battery()
            if battery is None:
                self.battery_info_label.setText("未檢測到電池")
                return
            
            # 更新電池數(shù)據(jù)
            self.batt_data.append(battery.percent)
            if len(self.batt_data) > 60:
                self.batt_data = self.batt_data[-60:]
            
            # 更新圖表
            self.batt_line.set_data(range(len(self.batt_data)), self.batt_data)
            self.batt_ax.set_ylim(0, 100)
            self.batt_canvas.draw()
            
            # 更新電池信息
            status = "充電中" if battery.power_plugged else "放電中"
            time_left = "N/A"
            if battery.secsleft != psutil.POWER_TIME_UNLIMITED:
                hours, remainder = divmod(battery.secsleft, 3600)
                minutes, _ = divmod(remainder, 60)
                time_left = f"{hours}h {minutes}m"
            
            info_text = (f"電池狀態(tài): {battery.percent}% | {status} | "
                        f"剩余時間: {time_left}")
            self.battery_info_label.setText(info_text)
            
            # 更新詳細信息
            detail_text = (f"是否充電: {'是' if battery.power_plugged else '否'}\n"
                         f"剩余電量: {battery.percent}%\n"
                         f"剩余時間: {time_left}\n"
                         f"電池狀態(tài): {status}")
            self.batt_detail_label.setText(detail_text)
            
        except Exception as e:
            self.battery_info_label.setText(f"電池監(jiān)控錯誤: {str(e)}")
    
    def get_temperatures(self):
        """獲取溫度數(shù)據(jù)"""
        temps = {}
        try:
            # CPU溫度
            if hasattr(psutil, "sensors_temperatures"):
                sensors = psutil.sensors_temperatures()
                for name, entries in sensors.items():
                    for entry in entries:
                        temps[f"{name}_{entry.label or 'temp'}"] = entry.current
            
            # GPU溫度 (需要額外庫)
            try:
                import GPUtil
                gpus = GPUtil.getGPUs()
                for i, gpu in enumerate(gpus):
                    temps[f"GPU_{i}"] = gpu.temperature
            except ImportError:
                pass
            
            # 如果沒有獲取到溫度數(shù)據(jù)，使用模擬數(shù)據(jù)
            if not temps:
                temps = {
                    "CPU": np.random.normal(50, 5),
                    "GPU": np.random.normal(60, 8)
                }
            
        except Exception:
            temps = {
                "CPU": np.random.normal(50, 5),
                "GPU": np.random.normal(60, 8)
            }
        
        return temps
    
    def get_fan_speeds(self):
        """獲取風扇轉速"""
        fans = {}
        try:
            if hasattr(psutil, "sensors_fans"):
                sensors = psutil.sensors_fans()
                for name, entries in sensors.items():
                    for i, entry in enumerate(entries):
                        fans[f"{name}_fan{i+1}"] = entry.current
        except Exception:
            pass
        
        return fans
    
    def get_voltages(self):
        """獲取電壓數(shù)據(jù)"""
        volts = {}
        try:
            # 需要特定平臺的實現(xiàn)
            pass
        except Exception:
            pass
        
        return volts
    
    def format_bytes(self, size):
        """格式化字節(jié)大小為易讀的字符串"""
        for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
            if size < 1024.0:
                return f"{size:.1f} {unit}"
            size /= 1024.0
        return f"{size:.1f} PB"
    
    def change_theme(self, theme_name):
        """切換主題"""
        self.current_theme = theme_name
        self.init_theme()
    
    def change_refresh_rate(self, interval):
        """更改刷新頻率"""
        self.timer.setInterval(interval)
    
    def detach_window(self):
        """分離當前標簽頁為獨立窗口"""
        current_tab = self.tabs.currentWidget()
        if current_tab:
            dock = QDockWidget(self.tabs.tabText(self.tabs.currentIndex()), self)
            dock.setWidget(current_tab)
            self.addDockWidget(Qt.RightDockWidgetArea, dock)
    
    def reset_layout(self):
        """重置窗口布局"""
        for dock in self.findChildren(QDockWidget):
            dock.close()
    
    def save_screenshot(self):
        """保存截圖"""
        # 實現(xiàn)截圖保存邏輯
        pass
    
    def export_data(self):
        """導出數(shù)據(jù)"""
        # 實現(xiàn)數(shù)據(jù)導出邏輯
        pass
    
    def keyPressEvent(self, event):
        """鍵盤事件處理"""
        if event.key() == Qt.Key_Q and event.modifiers() == Qt.ControlModifier:
            self.close()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    
    # 設置全局字體
    font = QFont("Consolas", 10)
    app.setFont(font)
    
    monitor = SystemMonitor()
    monitor.show()
    
    sys.exit(app.exec_())