pip install PyQt5 pynput

class HotkeyWorker(QObject):
    toggle_signal = pyqtSignal()
    
    def run(self):
        from pynput import keyboard
        
        def on_activate_f8():
            self.toggle_signal.emit()
            
        with keyboard.GlobalHotKeys({'<F8>': on_activate_f8}) as listener:
            listener.join()

class WordDisplayApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
        self.setAttribute(Qt.WA_TranslucentBackground)

self.settings = QSettings("WordDisplay", "WordDisplayApp")

# 保存配置
self.settings.setValue("interval", self.interval)

# 讀取配置
self.interval = self.settings.value("interval", 5, type=int)

def load_words(self):
    if self.order == "reverse":
        self.word_list.reverse()
    elif self.order == "random":
        random.shuffle(self.word_list)

def mousePressEvent(self, event):
    self.dragging = True
    self.offset = event.globalPos() - self.pos()

def mouseMoveEvent(self, event):
    if self.dragging:
        self.move(event.globalPos() - self.offset)

self.tray_icon = QSystemTrayIcon(self)
tray_menu = QMenu()
exit_action = QAction("退出", self)
exit_action.triggered.connect(self.quit_app)
tray_menu.addAction(exit_action)

import sys
import random
import os
from PyQt5.QtWidgets import (QApplication, QMainWindow, QLabel, QSystemTrayIcon,
                            QMenu, QAction, QWidget, QVBoxLayout, QPushButton,
                            QSpinBox, QComboBox, QColorDialog, QMessageBox, 
                            QDesktopWidget, QFileDialog)
from PyQt5.QtGui import QColor, QFont, QIcon, QPixmap, QCursor
from PyQt5.QtCore import Qt, QTimer, QSettings, QSize, QThread, pyqtSignal, QObject, QPoint

class HotkeyWorker(QObject):
    """處理全局快捷鍵的工作線程"""
    toggle_signal = pyqtSignal()
    error_signal = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.listener = None

    def run(self):
        """啟動熱鍵監(jiān)聽"""
        try:
            from pynput import keyboard

            def on_activate_f8():
                self.toggle_signal.emit()

            with keyboard.GlobalHotKeys({'<F8>': on_activate_f8}) as self.listener:
                self.listener.join()
        except ImportError as e:
            self.error_signal.emit("未安裝pynput庫，無法使用F8快捷鍵功能")
        except Exception as e:
            self.error_signal.emit(f"快捷鍵初始化失敗: {str(e)}")

    def stop(self):
        """停止熱鍵監(jiān)聽"""
        if self.listener:
            self.listener.stop()

class WordDisplayApp(QMainWindow):
    def __init__(self):
        super().__init__()
        
        # 初始化設(shè)置
        self.settings = QSettings("WordDisplay", "WordDisplayApp")
        self.load_settings()
        
        # 初始化UI
        self.init_ui()
        
        # 加載單詞數(shù)據(jù)
        self.word_list = []
        self.current_word_file = "words.txt"  # 默認(rèn)詞庫文件
        self.load_words()
        
        # 設(shè)置當(dāng)前單詞索引
        self.current_index = 0
        
        # 顯示第一個單詞
        self.show_word()
        
        # 設(shè)置定時器
        self.timer = QTimer()
        self.timer.timeout.connect(self.show_next_word)
        self.timer.start(self.interval * 1000)
        
        # 中文釋義是否顯示
        self.show_translation = False
        
        # 初始化熱鍵線程
        self.init_hotkey_thread()
        
        # 拖動相關(guān)變量
        self.dragging = False
        self.offset = QPoint()

    def init_hotkey_thread(self):
        """初始化熱鍵監(jiān)聽線程"""
        self.hotkey_thread = QThread()
        self.hotkey_worker = HotkeyWorker()
        self.hotkey_worker.moveToThread(self.hotkey_thread)
        
        # 連接信號
        self.hotkey_worker.toggle_signal.connect(self.toggle_translation)
        self.hotkey_worker.error_signal.connect(self.show_error_message)
        
        # 啟動線程
        self.hotkey_thread.started.connect(self.hotkey_worker.run)
        self.hotkey_thread.start()

    def show_error_message(self, message):
        """顯示錯誤消息"""
        QMessageBox.warning(self, "警告", message)

    def init_ui(self):
        """初始化用戶界面"""
        self.setWindowTitle("單詞顯示")
        self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint | Qt.Tool)
        self.setAttribute(Qt.WA_TranslucentBackground)
        
        # 創(chuàng)建主部件
        main_widget = QWidget()
        self.setCentralWidget(main_widget)
        
        # 布局
        layout = QVBoxLayout()
        layout.setContentsMargins(10, 10, 10, 10)
        main_widget.setLayout(layout)
        
        # 英文單詞標(biāo)簽
        self.word_label = QLabel("單詞加載中...")
        self.word_label.setAlignment(Qt.AlignCenter)
        self.word_label.setFont(QFont("Arial", self.english_font_size))
        self.word_label.setStyleSheet(f"color: {self.word_color.name()};")
        
        # 中文翻譯標(biāo)簽
        self.translation_label = QLabel()
        self.translation_label.setAlignment(Qt.AlignCenter)
        self.translation_label.setFont(QFont("微軟雅黑", self.chinese_font_size))
        self.translation_label.setStyleSheet(f"color: {self.translation_color.name()};")
        self.translation_label.hide()
        
        # 添加到布局
        layout.addWidget(self.word_label)
        layout.addWidget(self.translation_label)
        
        # 系統(tǒng)托盤圖標(biāo)
        self.init_system_tray()
        
        # 移動到右上角
        self.move_to_top_right()

    def init_system_tray(self):
        """初始化系統(tǒng)托盤圖標(biāo)"""
        self.tray_icon = QSystemTrayIcon(self)
        
        # 設(shè)置圖標(biāo)
        icon_path = os.path.join(os.path.dirname(__file__), "icon.ico")
        if os.path.exists(icon_path):
            self.tray_icon.setIcon(QIcon(icon_path))
        else:
            # 創(chuàng)建默認(rèn)圖標(biāo)
            pixmap = QPixmap(QSize(64, 64))
            pixmap.fill(Qt.transparent)
            self.tray_icon.setIcon(QIcon(pixmap))
            QMessageBox.warning(self, "圖標(biāo)未找到", f"未找到圖標(biāo)文件: {icon_path}")
        
        # 創(chuàng)建托盤菜單
        tray_menu = QMenu()
        
        # 顯示/隱藏主窗口
        toggle_action = QAction("顯示/隱藏", self)
        toggle_action.triggered.connect(self.toggle_visibility)
        tray_menu.addAction(toggle_action)
        
        # 重置位置
        reset_pos_action = QAction("重置位置", self)
        reset_pos_action.triggered.connect(self.move_to_top_right)
        tray_menu.addAction(reset_pos_action)
        
        # 設(shè)置
        settings_action = QAction("設(shè)置", self)
        settings_action.triggered.connect(self.show_settings_dialog)
        tray_menu.addAction(settings_action)
        
        # 加載詞庫
        load_dict_action = QAction("加載詞庫", self)
        load_dict_action.triggered.connect(self.load_new_dictionary)
        tray_menu.addAction(load_dict_action)
        
        # 退出
        exit_action = QAction("退出", self)
        exit_action.triggered.connect(self.quit_app)
        tray_menu.addAction(exit_action)
        
        self.tray_icon.setContextMenu(tray_menu)
        self.tray_icon.show()
        
        # 托盤圖標(biāo)點擊事件
        self.tray_icon.activated.connect(self.on_tray_icon_activated)

    def on_tray_icon_activated(self, reason):
        """托盤圖標(biāo)點擊事件處理"""
        if reason == QSystemTrayIcon.DoubleClick:
            self.toggle_visibility()

    def move_to_top_right(self):
        """將窗口移動到屏幕右上角"""
        screen = QDesktopWidget().screenGeometry()
        self.move(screen.width() - self.width() - 20, 20)

    def mousePressEvent(self, event):
        """鼠標(biāo)按下事件"""
        if event.button() == Qt.LeftButton:
            self.dragging = True
            self.offset = event.globalPos() - self.pos()
            event.accept()
            self.setCursor(QCursor(Qt.SizeAllCursor))

    def mouseMoveEvent(self, event):
        """鼠標(biāo)移動事件"""
        if self.dragging and event.buttons() & Qt.LeftButton:
            self.move(event.globalPos() - self.offset)
            event.accept()

    def mouseReleaseEvent(self, event):
        """鼠標(biāo)釋放事件"""
        if event.button() == Qt.LeftButton:
            self.dragging = False
            self.setCursor(QCursor(Qt.ArrowCursor))
            event.accept()

    def load_words(self, file_path=None):
        """從文件加載單詞數(shù)據(jù)"""
        try:
            if file_path is None:
                file_path = self.current_word_file
            
            with open(file_path, "r", encoding="utf-8") as f:
                self.word_list = []
                for line in f:
                    line = line.strip()
                    if line:
                        parts = line.split(maxsplit=1)
                        if len(parts) == 2:
                            self.word_list.append({
                                "word": parts[0],
                                "translation": parts[1]
                            })
            
            # 根據(jù)順序設(shè)置處理單詞列表
            if self.order == "reverse":
                self.word_list.reverse()
            elif self.order == "random":
                random.shuffle(self.word_list)
                
            if not self.word_list:
                self.word_list.append({
                    "word": "示例單詞",
                    "translation": "example translation"
                })
                
        except FileNotFoundError:
            QMessageBox.critical(self, "錯誤", f"未找到詞庫文件: {file_path}")
            self.word_list = [{
                "word": "示例單詞",
                "translation": "example translation"
            }]
        except Exception as e:
            QMessageBox.critical(self, "錯誤", f"加載詞庫失敗: {str(e)}")
            self.word_list = [{
                "word": "加載失敗",
                "translation": "load failed"
            }]

    def load_new_dictionary(self):
        """加載新的詞庫文件"""
        file_path, _ = QFileDialog.getOpenFileName(
            self, "選擇詞庫文件", "", "文本文件 (*.txt);;所有文件 (*)"
        )
        
        if file_path:
            self.current_word_file = file_path
            self.load_words(file_path)
            self.current_index = 0
            self.show_word()
            
            # 保存當(dāng)前詞庫路徑
            self.settings.setValue("current_word_file", file_path)

    def show_word(self):
        """顯示當(dāng)前單詞"""
        if not self.word_list:
            return
            
        word_data = self.word_list[self.current_index]
        self.word_label.setText(word_data["word"])
        self.translation_label.setText(word_data["translation"])

    def show_next_word(self):
        """顯示下一個單詞"""
        if not self.word_list:
            return
            
        if self.order == "random":
            self.current_index = random.randint(0, len(self.word_list) - 1)
        else:
            self.current_index += 1
            if self.current_index >= len(self.word_list):
                self.current_index = 0
        
        self.show_word()

    def toggle_translation(self):
        """切換翻譯顯示狀態(tài)"""
        self.show_translation = not self.show_translation
        self.translation_label.setVisible(self.show_translation)
        
        # 根據(jù)翻譯顯示狀態(tài)控制定時器
        if self.show_translation:
            self.timer.stop()  # 顯示翻譯時暫停計時器
        else:
            self.timer.start(self.interval * 1000)  # 隱藏翻譯時恢復(fù)計時器

    def show_settings_dialog(self):
        """顯示設(shè)置對話框"""
        self.settings_dialog = QWidget()
        self.settings_dialog.setWindowTitle("設(shè)置")
        self.settings_dialog.setWindowModality(Qt.ApplicationModal)
        self.settings_dialog.setFixedSize(350, 450)
        
        layout = QVBoxLayout()
        layout.setContentsMargins(10, 10, 10, 10)
        
        # 間隔時間設(shè)置
        interval_label = QLabel("顯示間隔(秒):")
        self.interval_spinbox = QSpinBox()
        self.interval_spinbox.setRange(1, 3600)
        self.interval_spinbox.setValue(self.interval)
        
        # 單詞順序設(shè)置
        order_label = QLabel("單詞順序:")
        self.order_combobox = QComboBox()
        self.order_combobox.addItems(["順序", "逆序", "隨機"])
        self.order_combobox.setCurrentIndex(["normal", "reverse", "random"].index(self.order))
        
        # 英文字體大小設(shè)置
        english_fontsize_label = QLabel("英文單詞字體大小:")
        self.english_fontsize_spinbox = QSpinBox()
        self.english_fontsize_spinbox.setRange(8, 72)
        self.english_fontsize_spinbox.setValue(self.english_font_size)
        
        # 中文字體大小設(shè)置
        chinese_fontsize_label = QLabel("中文翻譯字體大小:")
        self.chinese_fontsize_spinbox = QSpinBox()
        self.chinese_fontsize_spinbox.setRange(8, 72)
        self.chinese_fontsize_spinbox.setValue(self.chinese_font_size)
        
        # 單詞顏色設(shè)置
        word_color_label = QLabel("單詞顏色:")
        self.word_color_button = QPushButton()
        self.word_color_button.setStyleSheet(f"background-color: {self.word_color.name()};")
        self.word_color_button.clicked.connect(lambda: self.choose_color("word"))
        
        # 翻譯顏色設(shè)置
        trans_color_label = QLabel("翻譯顏色:")
        self.trans_color_button = QPushButton()
        self.trans_color_button.setStyleSheet(f"background-color: {self.translation_color.name()};")
        self.trans_color_button.clicked.connect(lambda: self.choose_color("translation"))
        
        # 保存按鈕
        save_button = QPushButton("保存設(shè)置")
        save_button.clicked.connect(self.save_settings)
        
        # 重新加載當(dāng)前詞庫按鈕
        reload_button = QPushButton("重新加載當(dāng)前詞庫")
        reload_button.clicked.connect(lambda: self.load_words(self.current_word_file))
        
        # 添加到布局
        layout.addWidget(interval_label)
        layout.addWidget(self.interval_spinbox)
        layout.addWidget(order_label)
        layout.addWidget(self.order_combobox)
        layout.addWidget(english_fontsize_label)
        layout.addWidget(self.english_fontsize_spinbox)
        layout.addWidget(chinese_fontsize_label)
        layout.addWidget(self.chinese_fontsize_spinbox)
        layout.addWidget(word_color_label)
        layout.addWidget(self.word_color_button)
        layout.addWidget(trans_color_label)
        layout.addWidget(self.trans_color_button)
        layout.addWidget(save_button)
        layout.addWidget(reload_button)
        layout.addStretch()
        
        self.settings_dialog.setLayout(layout)
        self.settings_dialog.show()

    def choose_color(self, color_type):
        """選擇顏色"""
        color = QColorDialog.getColor()
        if color.isValid():
            if color_type == "word":
                self.word_color = color
                self.word_color_button.setStyleSheet(f"background-color: {color.name()};")
            else:
                self.translation_color = color
                self.trans_color_button.setStyleSheet(f"background-color: {color.name()};")

    def save_settings(self):
        """保存設(shè)置"""
        self.interval = self.interval_spinbox.value()
        
        order_index = self.order_combobox.currentIndex()
        if order_index == 0:
            self.order = "normal"
        elif order_index == 1:
            self.order = "reverse"
        else:
            self.order = "random"
        
        self.english_font_size = self.english_fontsize_spinbox.value()
        self.chinese_font_size = self.chinese_fontsize_spinbox.value()
        
        # 保存到QSettings
        self.settings.setValue("interval", self.interval)
        self.settings.setValue("order", self.order)
        self.settings.setValue("english_font_size", self.english_font_size)
        self.settings.setValue("chinese_font_size", self.chinese_font_size)
        self.settings.setValue("word_color", self.word_color.name())
        self.settings.setValue("translation_color", self.translation_color.name())
        
        # 應(yīng)用設(shè)置
        self.apply_settings()
        self.settings_dialog.close()

    def apply_settings(self):
        """應(yīng)用當(dāng)前設(shè)置"""
        # 更新定時器間隔
        self.timer.stop()
        if not self.show_translation:  # 只有隱藏翻譯時才啟動計時器
            self.timer.start(self.interval * 1000)
        
        # 更新字體大小
        self.word_label.setFont(QFont("Arial", self.english_font_size))
        self.translation_label.setFont(QFont("微軟雅黑", self.chinese_font_size))
        
        # 更新顏色
        self.word_label.setStyleSheet(f"color: {self.word_color.name()};")
        self.translation_label.setStyleSheet(f"color: {self.translation_color.name()};")
        
        # 如果需要，重新排序單詞
        if self.order == "reverse":
            self.word_list.reverse()
        elif self.order == "random":
            random.shuffle(self.word_list)
        
        # 重置索引
        self.current_index = 0
        self.show_word()

    def toggle_visibility(self):
        """切換窗口可見性"""
        if self.isVisible():
            self.hide()
        else:
            self.show()
            self.move_to_top_right()

    def quit_app(self):
        """退出應(yīng)用程序"""
        # 停止熱鍵線程
        if hasattr(self, 'hotkey_thread'):
            self.hotkey_worker.stop()
            self.hotkey_thread.quit()
            self.hotkey_thread.wait()
        
        # 保存設(shè)置
        self.settings.sync()
        QApplication.quit()

    def closeEvent(self, event):
        """重寫關(guān)閉事件"""
        event.ignore()
        self.hide()

    def load_settings(self):
        """加載設(shè)置"""
        # 默認(rèn)設(shè)置
        self.interval = self.settings.value("interval", 5, type=int)
        self.order = self.settings.value("order", "normal")
        self.english_font_size = self.settings.value("english_font_size", 24, type=int)
        self.chinese_font_size = self.settings.value("chinese_font_size", 20, type=int)
        self.current_word_file = self.settings.value("current_word_file", "words.txt")
        
        # 顏色設(shè)置
        self.word_color = QColor(self.settings.value("word_color", "#000000"))
        self.translation_color = QColor(self.settings.value("translation_color", "#888888"))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    app.setQuitOnLastWindowClosed(False)
    
    # 設(shè)置應(yīng)用程序圖標(biāo)
    icon_path = os.path.join(os.path.dirname(__file__), "icon.ico")
    if os.path.exists(icon_path):
        app.setWindowIcon(QIcon(icon_path))
    
    word_app = WordDisplayApp()
    word_app.hide()
    
    sys.exit(app.exec_())

# 使用LRU緩存最近顯示的單詞
from functools import lru_cache

@lru_cache(maxsize=50)
def get_word_style(word):
    return generate_style(word)