je-editor 0.0.202__py3-none-any.whl → 0.0.228__py3-none-any.whl

je_editor/pyside_ui/main_ui/menu/language_menu/build_language_server.py

@@ -1,36 +1,64 @@
+# 匯入未來功能，允許延遲型別註解 (Python 3.7+ 常用)
+# Import future feature: postponed evaluation of type annotations
 from __future__ import annotations
 
+# 僅用於型別檢查，避免循環匯入
+# For type checking only (avoids circular imports)
 from typing import TYPE_CHECKING
 
+# 匯入 Qt 動作與訊息框
+# Import QAction and QMessageBox from PySide6
 from PySide6.QtGui import QAction
 from PySide6.QtWidgets import QMessageBox
 
+# 匯入使用者設定字典，用來保存語言設定
+# Import user settings dictionary for saving language preferences
 from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import user_setting_dict
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
+# 僅在型別檢查時匯入 EditorMain，避免循環依賴
+# Import EditorMain only for type checking (avoids circular dependency)
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
 
+# 匯入多語言包裝器，用於 UI 多語言顯示
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 設定語言選單
+# Set up the Language menu
 def set_language_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_language_server.py set_language_menu ui_we_want_to_set: {ui_we_want_to_set}")
+
+    # 建立 Language 選單
+    # Create Language menu
     ui_we_want_to_set.language_menu = ui_we_want_to_set.menu.addMenu(
         language_wrapper.language_word_dict.get("language_menu_label")
     )
+
+    # 建立「切換到英文」動作
+    # Add "Switch to English" action
     ui_we_want_to_set.language_menu.change_to_english_language_action = QAction(
         language_wrapper.language_word_dict.get("language_menu_bar_english")
     )
     ui_we_want_to_set.language_menu.change_to_english_language_action.triggered.connect(
         lambda: set_language("English", ui_we_want_to_set)
     )
+
+    # 建立「切換到繁體中文」動作
+    # Add "Switch to Traditional Chinese" action
     ui_we_want_to_set.language_menu.change_to_traditional_chinese_language_action = QAction(
         language_wrapper.language_word_dict.get("language_menu_bar_traditional_chinese")
     )
     ui_we_want_to_set.language_menu.change_to_traditional_chinese_language_action.triggered.connect(
         lambda: set_language("Traditional_Chinese", ui_we_want_to_set)
     )
+
+    # 將動作加入選單
+    # Add actions to the menu
     ui_we_want_to_set.language_menu.addAction(
         ui_we_want_to_set.language_menu.change_to_english_language_action
     )
@@ -39,12 +67,23 @@ def set_language_menu(ui_we_want_to_set: EditorMain) -> None:
     )
 
 
+# 設定語言
+# Set the application language
 def set_language(language: str, ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info("build_language_server.py set_language "
                         f"language: {language} "
                         f"ui_we_want_to_set: {ui_we_want_to_set}")
+
+    # 重設語言 (更新多語言字典)
+    # Reset language (update multi-language dictionary)
     language_wrapper.reset_language(language)
+
+    # 更新使用者設定，保存語言偏好
+    # Update user settings dictionary to persist language preference
     user_setting_dict.update({"language": language})
+
+    # 顯示提示訊息，提醒使用者需要重新啟動程式
+    # Show a message box to remind user to restart the application
     message_box = QMessageBox(ui_we_want_to_set)
     message_box.setText(language_wrapper.language_word_dict.get("language_menu_bar_please_restart_messagebox"))
     message_box.show()

je_editor/pyside_ui/main_ui/menu/python_env_menu/build_venv_menu.py

@@ -1,68 +1,91 @@
+# 匯入未來功能，允許延遲型別註解 (Python 3.7+ 常用)
+# Import future feature: postponed evaluation of type annotations
 from __future__ import annotations
 
+# 僅用於型別檢查，避免循環匯入
+# For type checking only (avoids circular imports)
 from typing import TYPE_CHECKING
 
+# 匯入編輯器元件
+# Import EditorWidget
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+# 匯入顏色設定，用於輸出訊息時的字體顏色
+# Import color settings for console/text output
+from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import actually_color_dict
+# 匯入使用者設定字典，用來保存 Python 解譯器與環境設定
+# Import user settings dictionary for saving Python interpreter and environment settings
 from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import user_setting_dict
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
+# 僅在型別檢查時匯入 EditorMain，避免循環依賴
+# Import EditorMain only for type checking (avoids circular dependency)
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+
 import os
 from pathlib import Path
 
-from PySide6.QtGui import QAction, QKeySequence
+# 匯入 Qt 動作、快捷鍵、文字格式、訊息框、輸入框、檔案對話框
+# Import QAction, QKeySequence, QTextCharFormat, QMessageBox, QInputDialog, QFileDialog
+from PySide6.QtGui import QAction, QKeySequence, QTextCharFormat
 from PySide6.QtWidgets import QMessageBox, QInputDialog, QFileDialog
 
+# 匯入 ShellManager，用於執行系統命令 (建立 venv、pip install 等)
+# Import ShellManager for executing shell commands (create venv, pip install, etc.)
 from je_editor.pyside_ui.code.shell_process.shell_exec import ShellManager
 
+# 匯入多語言包裝器，用於 UI 多語言顯示
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 設定 Python 環境選單 (venv menu)
+# Set up the Python Environment (venv) menu
 def set_venv_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py set_venv_menu ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.venv_menu = ui_we_want_to_set.menu.addMenu(
         language_wrapper.language_word_dict.get("python_env_menu_label"))
-    # Create an venv
+
+    # 建立虛擬環境 (Ctrl+Shift+V)
+    # Create virtual environment
     ui_we_want_to_set.venv_menu.change_language_menu = QAction(
         language_wrapper.language_word_dict.get("python_env_menu_create_venv_label"))
-    ui_we_want_to_set.venv_menu.change_language_menu.setShortcut(
-        QKeySequence("Ctrl+Shift+V")
-    )
+    ui_we_want_to_set.venv_menu.change_language_menu.setShortcut(QKeySequence("Ctrl+Shift+V"))
     ui_we_want_to_set.venv_menu.change_language_menu.triggered.connect(
-        lambda: create_venv(ui_we_want_to_set)
-    )
+        lambda: create_venv(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.change_language_menu)
+
+    # pip 升級套件 (Ctrl+Shift+U)
     # pip upgrade package
     ui_we_want_to_set.venv_menu.pip_upgrade_action = QAction(
-        language_wrapper.language_word_dict.get("python_env_menu_pip_upgrade_label")
-    )
-    ui_we_want_to_set.venv_menu.pip_upgrade_action.setShortcut(
-        QKeySequence("Ctrl+Shift+U")
-    )
+        language_wrapper.language_word_dict.get("python_env_menu_pip_upgrade_label"))
+    ui_we_want_to_set.venv_menu.pip_upgrade_action.setShortcut(QKeySequence("Ctrl+Shift+U"))
     ui_we_want_to_set.venv_menu.pip_upgrade_action.triggered.connect(
-        lambda: pip_install_package_update(ui_we_want_to_set)
-    )
+        lambda: pip_install_package_update(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.pip_upgrade_action)
-    # pip package
+
+    # pip 安裝套件 (Ctrl+Shift+P)
+    # pip install package
     ui_we_want_to_set.venv_menu.pip_action = QAction(
         language_wrapper.language_word_dict.get("python_env_menu_pip_label"))
-    ui_we_want_to_set.venv_menu.pip_action.setShortcut(
-        QKeySequence("Ctrl+Shift+P")
-    )
+    ui_we_want_to_set.venv_menu.pip_action.setShortcut(QKeySequence("Ctrl+Shift+P"))
     ui_we_want_to_set.venv_menu.pip_action.triggered.connect(
-        lambda: pip_install_package(ui_we_want_to_set)
-    )
+        lambda: pip_install_package(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.pip_action)
-    # choose python interpreter
+
+    # 選擇 Python 解譯器
+    # Choose Python interpreter
     ui_we_want_to_set.venv_menu.choose_interpreter_action = QAction(
         language_wrapper.language_word_dict.get("python_env_menu_choose_interpreter_label"))
     ui_we_want_to_set.venv_menu.choose_interpreter_action.triggered.connect(
-        lambda: chose_python_interpreter(ui_we_want_to_set)
-    )
+        lambda: chose_python_interpreter(ui_we_want_to_set))
     ui_we_want_to_set.venv_menu.addAction(ui_we_want_to_set.venv_menu.choose_interpreter_action)
 
 
+# 建立虛擬環境
+# Create virtual environment
 def create_venv(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py create_venv ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
@@ -70,21 +93,31 @@ def create_venv(ui_we_want_to_set: EditorMain) -> None:
         widget.python_compiler = ui_we_want_to_set.python_compiler
         venv_path = Path(os.getcwd() + "/venv")
         if not venv_path.exists():
+            # 使用 ShellManager 執行 python -m venv venv
+            # Use ShellManager to run python -m venv venv
             create_venv_shell = ShellManager(main_window=widget, after_done_function=widget.code_edit.check_env,
                                              shell_encoding=ui_we_want_to_set.encoding)
             create_venv_shell.later_init()
-            create_venv_shell.exec_shell(
-                [f"{create_venv_shell.compiler_path}", "-m", "venv", "venv"]
-            )
-            widget.code_result.append(
-                language_wrapper.language_word_dict.get("python_env_menu_creating_venv_message"))
+            create_venv_shell.exec_shell([f"{create_venv_shell.compiler_path}", "-m", "venv", "venv"])
+
+            # 在編輯器輸出區顯示訊息
+            # Show message in editor output area
+            text_cursor = widget.code_result.textCursor()
+            text_format = QTextCharFormat()
+            text_format.setForeground(actually_color_dict.get("normal_output_color"))
+            text_cursor.insertText(language_wrapper.language_word_dict.get("python_env_menu_creating_venv_message"),
+                                   text_format)
+            text_cursor.insertBlock()
         else:
+            # 如果 venv 已存在，顯示提示訊息
+            # If venv exists, show message
             message_box = QMessageBox()
-            message_box.setText(
-                language_wrapper.language_word_dict.get("python_env_menu_venv_exists"))
+            message_box.setText(language_wrapper.language_word_dict.get("python_env_menu_venv_exists"))
             message_box.exec()
 
 
+# 使用 pip 安裝套件 (通用函式)
+# Run pip install command (general function)
 def shell_pip_install(ui_we_want_to_set: EditorMain, pip_install_command_list: list):
     jeditor_logger.info("build_venv_menu.py create_venv "
                         f"ui_we_want_to_set: {ui_we_want_to_set} "
@@ -94,10 +127,14 @@ def shell_pip_install(ui_we_want_to_set: EditorMain, pip_install_command_list: l
         widget.python_compiler = ui_we_want_to_set.python_compiler
         venv_path = Path(os.getcwd() + "/venv")
         if not venv_path.exists():
+            # 如果 venv 不存在，提醒使用者先建立
+            # If venv does not exist, remind user to create it first
             message_box = QMessageBox()
             message_box.setText(language_wrapper.language_word_dict.get("python_env_menu_please_create_venv"))
             message_box.exec()
         else:
+            # 彈出輸入框，讓使用者輸入套件名稱
+            # Ask user to input package name
             ask_package_dialog = QInputDialog()
             package_text, press_ok = ask_package_dialog.getText(
                 ui_we_want_to_set,
@@ -107,11 +144,11 @@ def shell_pip_install(ui_we_want_to_set: EditorMain, pip_install_command_list: l
             if press_ok:
                 pip_install_shell = ShellManager(main_window=widget, shell_encoding=ui_we_want_to_set.encoding)
                 pip_install_shell.later_init()
-                pip_install_shell.exec_shell(
-                    pip_install_command_list
-                )
+                pip_install_shell.exec_shell(pip_install_command_list)
 
 
+# 偵測 venv 是否存在
+# Detect if venv exists
 def detect_venv() -> bool:
     jeditor_logger.info("build_venv_menu.py detect_venv")
     venv_path = Path(os.getcwd() + "/venv")
@@ -120,15 +157,20 @@ def detect_venv() -> bool:
         message_box.setText(language_wrapper.language_word_dict.get("python_env_menu_please_create_venv"))
         message_box.exec()
         return False
-    return True
+    else:
+        return True
 
 
+# pip 安裝或更新套件
+# pip install or update package
 def pip_install_package_update(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py pip_install_package_update ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
         widget.python_compiler = ui_we_want_to_set.python_compiler
-        if detect_venv:
+        if detect_venv():
+            # 彈出輸入框，讓使用者輸入要安裝或更新的套件名稱
+            # Ask user to input package name to install or update
             ask_package_dialog = QInputDialog()
             package_text, press_ok = ask_package_dialog.getText(
                 ui_we_want_to_set,
@@ -136,20 +178,29 @@ def pip_install_package_update(ui_we_want_to_set: EditorMain) -> None:
                 language_wrapper.language_word_dict.get("python_env_menu_install_or_update_package_messagebox_label")
             )
             if press_ok:
-                pip_install_shell = ShellManager(main_window=widget, after_done_function=widget.code_edit.check_env,
-                                                 shell_encoding=ui_we_want_to_set.encoding)
+                # 使用 ShellManager 執行 pip install -U
+                # Use ShellManager to run pip install -U
+                pip_install_shell = ShellManager(
+                    main_window=widget,
+                    after_done_function=widget.code_edit.check_env,
+                    shell_encoding=ui_we_want_to_set.encoding
+                )
                 pip_install_shell.later_init()
                 pip_install_shell.exec_shell(
                     [f"{pip_install_shell.compiler_path}", "-m", "pip", "install", f"{package_text}", "-U"]
                 )
 
 
+# pip 安裝套件 (不加 -U)
+# pip install package (without -U)
 def pip_install_package(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_venv_menu.py pip_install_package ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
         widget.python_compiler = ui_we_want_to_set.python_compiler
-        if detect_venv:
+        if detect_venv():
+            # 彈出輸入框，讓使用者輸入要安裝的套件名稱
+            # Ask user to input package name
             ask_package_dialog = QInputDialog()
             package_text, press_ok = ask_package_dialog.getText(
                 ui_we_want_to_set,
@@ -157,14 +208,21 @@ def pip_install_package(ui_we_want_to_set: EditorMain) -> None:
                 language_wrapper.language_word_dict.get("python_env_menu_install_package_messagebox_label")
             )
             if press_ok:
-                pip_install_shell = ShellManager(main_window=widget, after_done_function=widget.code_edit.check_env,
-                                                 shell_encoding=ui_we_want_to_set.encoding)
+                # 使用 ShellManager 執行 pip install
+                # Use ShellManager to run pip install
+                pip_install_shell = ShellManager(
+                    main_window=widget,
+                    after_done_function=widget.code_edit.check_env,
+                    shell_encoding=ui_we_want_to_set.encoding
+                )
                 pip_install_shell.later_init()
                 pip_install_shell.exec_shell(
                     [f"{pip_install_shell.compiler_path}", "-m", "pip", "install", f"{package_text}"]
                 )
 
 
+# 選擇 Python 解譯器
+# Choose Python interpreter
 def chose_python_interpreter(ui_we_want_to_set: EditorMain):
     jeditor_logger.info(f"build_venv_menu.py chose_python_interpreter ui_we_want_to_set: {ui_we_want_to_set}")
     file_path = QFileDialog().getOpenFileName(
@@ -172,5 +230,9 @@ def chose_python_interpreter(ui_we_want_to_set: EditorMain):
         dir=str(Path.cwd())
     )[0]
     if file_path is not None and file_path != "":
+        # 更新主程式的 Python 解譯器路徑
+        # Update main editor's Python interpreter path
         ui_we_want_to_set.python_compiler = file_path
+        # 同時更新使用者設定，讓下次啟動時能記住
+        # Update user settings so it persists across sessions
         user_setting_dict.update({"python_compiler": file_path})

je_editor/pyside_ui/main_ui/menu/run_menu/build_run_menu.py

@@ -2,61 +2,95 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+# 匯入 Qt 訊息框
+# Import QMessageBox for showing dialogs
 from PySide6.QtWidgets import QMessageBox
 
+# 匯入執行中程序管理器，用於統一管理所有程式/除錯器/Shell 執行實例
+# Import run_instance_manager for managing all running processes
 from je_editor.pyside_ui.code.running_process_manager import run_instance_manager
+# 匯入編輯器元件
+# Import EditorWidget
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+# 匯入子選單建構函式 (Program / Debug / Shell)
+# Import submenu builders (Program / Debug / Shell)
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.build_debug_menu import set_debug_menu
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.build_program_menu import set_program_menu
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.build_shell_menu import set_shell_menu
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+
+# 匯入 Qt 動作
+# Import QAction
 from PySide6.QtGui import QAction
 
+# 匯入多語言包裝器
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 設定 Run 選單
+# Set up the Run menu
 def set_run_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_run_menu.py set_run_menu ui_we_want_to_set: {ui_we_want_to_set}")
+    # 建立 Run 選單
+    # Create Run menu
     ui_we_want_to_set.run_menu = ui_we_want_to_set.menu.addMenu(
         language_wrapper.language_word_dict.get("run_menu_label"))
+
+    # 加入子選單：Program / Shell / Debug
+    # Add submenus: Program / Shell / Debug
     set_program_menu(ui_we_want_to_set)
     set_shell_menu(ui_we_want_to_set)
     set_debug_menu(ui_we_want_to_set)
-    # Clean result
+
+    # 清除結果
+    # Clear execution result
     ui_we_want_to_set.run_menu.clean_result_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_clear_result_label"))
     ui_we_want_to_set.run_menu.clean_result_action.triggered.connect(
         lambda: clean_result(ui_we_want_to_set)
     )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_menu.clean_result_action)
-    # Close program
+
+    # 停止目前程式
+    # Stop current program
     ui_we_want_to_set.run_menu.stop_program_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_stop_program_label"))
     ui_we_want_to_set.run_menu.stop_program_action.triggered.connect(
         lambda: stop_program(ui_we_want_to_set)
     )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_menu.stop_program_action)
-    # Close all program
+
+    # 停止所有程式
+    # Stop all programs
     ui_we_want_to_set.run_menu.stop_all_program_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_stop_all_program_label"))
     ui_we_want_to_set.run_menu.stop_all_program_action.triggered.connect(
         stop_all_program
     )
     ui_we_want_to_set.run_menu.addAction(ui_we_want_to_set.run_menu.stop_all_program_action)
-    # Run help menu
+
+    # Run 說明子選單
+    # Run Help submenu
     ui_we_want_to_set.run_menu.run_help_menu = ui_we_want_to_set.run_menu.addMenu(
         language_wrapper.language_word_dict.get("run_menu_run_help_label"))
-    # Run help action
+
+    # Run 說明動作
+    # Run Help action
     ui_we_want_to_set.run_menu.run_help_menu.run_help_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_run_help_label"))
     ui_we_want_to_set.run_menu.run_help_menu.run_help_action.triggered.connect(
         show_run_help
     )
     ui_we_want_to_set.run_menu.run_help_menu.addAction(ui_we_want_to_set.run_menu.run_help_menu.run_help_action)
-    # Shell help action
+
+    # Shell 說明動作
+    # Shell Help action
     ui_we_want_to_set.run_menu.run_help_menu.shell_help_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_shell_help_label"))
     ui_we_want_to_set.run_menu.run_help_menu.shell_help_action.triggered.connect(
@@ -65,29 +99,38 @@ def set_run_menu(ui_we_want_to_set: EditorMain) -> None:
     ui_we_want_to_set.run_menu.run_help_menu.addAction(ui_we_want_to_set.run_menu.run_help_menu.shell_help_action)
 
 
+# 停止目前分頁的程式 / Shell / 除錯器
+# Stop current tab's program / shell / debugger
 def stop_program(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_run_menu.py stop_program ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
+        # 停止程式
         if widget.exec_program is not None:
             if widget.exec_program.process is not None:
                 widget.exec_program.process.terminate()
             widget.exec_program = None
+        # 停止 Shell
         if widget.exec_shell is not None:
             if widget.exec_shell.process is not None:
                 widget.exec_shell.process.terminate()
             widget.exec_shell = None
+        # 停止除錯器
         if widget.exec_python_debugger is not None:
             if widget.exec_python_debugger.process is not None:
                 widget.exec_python_debugger.process.terminate()
             widget.exec_python_debugger = None
 
 
+# 停止所有執行中的程式
+# Stop all running programs
 def stop_all_program() -> None:
     jeditor_logger.info("build_run_menu.py stop_all_program")
     run_instance_manager.close_all_instance()
 
 
+# 清除目前分頁的輸出結果
+# Clear current tab's output result
 def clean_result(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_run_menu.py clean_result ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
@@ -95,6 +138,8 @@ def clean_result(ui_we_want_to_set: EditorMain) -> None:
         widget.code_result.setPlainText("")
 
 
+# 顯示 Run 說明
+# Show Run help
 def show_run_help() -> None:
     jeditor_logger.info("build_run_menu.py show_run_help")
     message_box = QMessageBox()
@@ -104,6 +149,8 @@ def show_run_help() -> None:
     message_box.exec()
 
 
+# 顯示 Shell 說明
+# Show Shell help
 def show_shell_help() -> None:
     jeditor_logger.info("build_run_menu.py show_shell_help")
     message_box = QMessageBox()

je_editor/pyside_ui/main_ui/menu/run_menu/under_run_menu/build_debug_menu.py

@@ -1,34 +1,64 @@
+# 匯入未來功能，允許延遲型別註解 (Python 3.7+ 常用)
+# Import future feature: postponed evaluation of type annotations
 from __future__ import annotations
 
+# 僅用於型別檢查，避免循環匯入
+# For type checking only (avoids circular imports)
 from typing import TYPE_CHECKING
 
+# 匯入編輯器元件與輸入處理
+# Import EditorWidget and ProcessInput
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
 from je_editor.pyside_ui.main_ui.editor.process_input import ProcessInput
+# 匯入工具函式：顯示「請先關閉目前執行中的程式」訊息框
+# Import utility: show message box if a program is already running
 from je_editor.pyside_ui.main_ui.menu.run_menu.under_run_menu.utils import please_close_current_running_messagebox
+# 匯入日誌紀錄器
+# Import logger instance
 from je_editor.utils.logging.loggin_instance import jeditor_logger
 
+# 僅在型別檢查時匯入 EditorMain，避免循環依賴
+# Import EditorMain only for type checking (avoids circular dependency)
 if TYPE_CHECKING:
     from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+
+# 匯入 Qt 動作
+# Import QAction
 from PySide6.QtGui import QAction
 
+# 匯入程式執行管理器 (ExecManager)
+# Import ExecManager for running/debugging code
 from je_editor.pyside_ui.code.code_process.code_exec import ExecManager
+
+# 匯入檔案儲存對話框
+# Import file save dialog
 from je_editor.pyside_ui.dialog.file_dialog.save_file_dialog import choose_file_get_save_file_path
+
+# 匯入多語言包裝器
+# Import multi-language wrapper for UI localization
 from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
 
 
+# 設定 Debug 選單
+# Set up the Debug menu
 def set_debug_menu(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_debug_menu.py set_debug_menu ui_we_want_to_set: {ui_we_want_to_set}")
-    # Debug menu inside run menu
+    # 在 Run 選單下建立 Debug 子選單
+    # Create Debug submenu under Run menu
     ui_we_want_to_set.debug_menu = ui_we_want_to_set.run_menu.addMenu(
         language_wrapper.language_word_dict.get("editor_debugger_input_title_label"))
-    # Run debugger
+
+    # 建立「執行除錯器」動作
+    # Add "Run Debugger" action
     ui_we_want_to_set.debug_menu.run_debugger_action = QAction(
         language_wrapper.language_word_dict.get("run_menu_run_debugger"))
     ui_we_want_to_set.debug_menu.run_debugger_action.triggered.connect(
         lambda: run_debugger(ui_we_want_to_set)
     )
     ui_we_want_to_set.debug_menu.addAction(ui_we_want_to_set.debug_menu.run_debugger_action)
-    # Show debugger input
+
+    # 建立「顯示除錯輸入」動作
+    # Add "Show Debugger Input" action
     ui_we_want_to_set.debug_menu.show_shell_input = QAction(
         language_wrapper.language_word_dict.get("show_debugger_input"))
     ui_we_want_to_set.debug_menu.show_shell_input.triggered.connect(
@@ -37,26 +67,40 @@ def set_debug_menu(ui_we_want_to_set: EditorMain) -> None:
     ui_we_want_to_set.debug_menu.addAction(ui_we_want_to_set.debug_menu.show_shell_input)
 
 
+# 執行除錯器 (pdb)
+# Run debugger (pdb)
 def run_debugger(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_debug_menu.py run_debugger ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()
     if isinstance(widget, EditorWidget):
+        # 確保沒有正在執行的除錯器
+        # Ensure no debugger is already running
         if widget.exec_python_debugger is None:
             widget.python_compiler = ui_we_want_to_set.python_compiler
+            # 要求使用者選擇儲存檔案路徑
+            # Ask user to choose save file path
             if choose_file_get_save_file_path(ui_we_want_to_set):
+                # 建立程式執行管理器，並以 pdb 模式執行
+                # Create ExecManager and run with pdb
                 code_exec = ExecManager(widget, program_encoding=ui_we_want_to_set.encoding)
                 code_exec.later_init()
                 code_exec.code_result = widget.debugger_result
                 code_exec.exec_code(
                     widget.current_file, exec_prefix=["-m", "pdb"]
                 )
+                # 綁定除錯器與輸入介面
+                # Bind debugger and input interface
                 widget.exec_python_debugger = code_exec
                 widget.debugger_input = ProcessInput(widget)
                 widget.debugger_input.show()
         else:
+            # 如果已有程式在執行，顯示提示訊息
+            # If a program is already running, show message
             please_close_current_running_messagebox(ui_we_want_to_set)
 
 
+# 顯示除錯輸入介面
+# Show debugger input interface
 def show_debugger_input(ui_we_want_to_set: EditorMain) -> None:
     jeditor_logger.info(f"build_debug_menu.py show_debugger_input ui_we_want_to_set: {ui_we_want_to_set}")
     widget = ui_we_want_to_set.tab_widget.currentWidget()